/*
 * JPA DAO Template
 *
 *
 * Takatuka - Template fuer JPA DAO
 *
 */

package de.ivu.elect.business.stimmeingabe.boundary;

import javax.persistence.NoResultException;
import javax.persistence.NonUniqueResultException;
import javax.persistence.EntityNotFoundException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import de.ivu.elect.business.stimmeingabe.entity.Ergebniseingang;
import de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangUK;

public abstract class AbstractErgebniseingangDAO extends de.ivu.elect.jee.entity.AbstractDAO<Ergebniseingang,
        de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangPK
    , ErgebniseingangUK> {

  private static final long serialVersionUID = 1L;

  private static final Logger LOG = LoggerFactory.getLogger(AbstractErgebniseingangDAO.class);

  public AbstractErgebniseingangDAO() {
    super();
  }

  public boolean isEntityWithPKPresent(
            de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangPK
     pk) {
    if (pk != null && pk.getId() != null) {
      return findByPrimaryKey(pk) != null;
    }

    return false;
  }

  @Override
  public Ergebniseingang findByPrimaryKey(
        de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangPK
      pk) {
    if (pk != null && pk.getId() != null) {
      return findByPrimaryKey(pk.getId());
    }

    throw new IllegalArgumentException("PK oder PK.getId() ist null! [pk = " + pk + "]");
  }


  @Override
  protected Ergebniseingang findByPrimaryKey(Long id) {
    if (id == null) {
      throw new IllegalArgumentException("ID ist null! [id = " + id + "]");
    }
  return getEntityManager().find(Ergebniseingang.class, id, CACHE_PROPERTIES);
  }



     /**
      * Name: ByGebietNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: DELETE FROM Ergebniseingang o WHERE o.wahldurchfuehrungsgebiet = ?1<br>
      * SQL: <br>
      */
     public Integer deleteByGebiet( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  
                              return
                    (Integer)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.ByGebiet")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                                                                .executeUpdate();
          
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, deleteByGebiet - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".deleteByGebiet(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: ByWahlNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: DELETE FROM Ergebniseingang o WHERE EXISTS (SELECT g FROM Wahldurchfuehrungsgebiet g WHERE o.wahldurchfuehrungsgebiet = g AND g.wahl=?1)<br>
      * SQL: <br>
      */
     public Integer deleteByWahl( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  
                              return
                    (Integer)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.ByWahl")
                              .setParameter(1, wahlCheckedAndAttached)
                                                                                .executeUpdate();
          
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, deleteByWahl - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".deleteByWahl(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: CountErgebnissequenznummerIsNullByWahlEingangsArtNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT COUNT(o) FROM Ergebniseingang o WHERE o.ergebnissequenznummer IS NULL AND o.wahldurchfuehrungsgebiet.wahl = ?1 AND o.ergebniseingangsart = ?2<br>
      * SQL: <br>
      */
     public java.lang.Long findByCountErgebnissequenznummerIsNullByWahlEingangsArt( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.CountErgebnissequenznummerIsNullByWahlEingangsArt")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                                                      .getSingleResult();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByCountErgebnissequenznummerIsNullByWahlEingangsArt - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByCountErgebnissequenznummerIsNullByWahlEingangsArt - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByCountErgebnissequenznummerIsNullByWahlEingangsArt(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: CountErgebnissequenznummerIsNullNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT COUNT(o) FROM Ergebniseingang o WHERE o.ergebnissequenznummer IS NulL<br>
      * SQL: <br>
      */
     public java.lang.Long findByCountErgebnissequenznummerIsNull() {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.CountErgebnissequenznummerIsNull")
                                                            .getSingleResult();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByCountErgebnissequenznummerIsNull - NonUniqueResultException, Parameter: "
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByCountErgebnissequenznummerIsNull(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: CountGebietNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT COUNT(o) FROM Ergebniseingang o WHERE o.wahldurchfuehrungsgebiet = ?1<br>
      * SQL: <br>
      */
     public java.lang.Long findByCountGebiet( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.CountGebiet")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                                                      .getSingleResult();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByCountGebiet - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByCountGebiet - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByCountGebiet(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: CountWahlNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT COUNT(o) FROM Ergebniseingang o WHERE o.wahldurchfuehrungsgebiet.wahl = ?1<br>
      * SQL: <br>
      */
     public java.lang.Long findByCountWahl( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.CountWahl")
                              .setParameter(1, wahlCheckedAndAttached)
                                                                      .getSingleResult();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByCountWahl - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByCountWahl - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByCountWahl(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: EingeflossenInErgebnisNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT ee FROM Ergebniseingang ee WHERE EXISTS (SELECT ege FROM ErgebnisGueltigerEingang ege WHERE ege.ergebniseingang = ee AND ege.ergebnis = ?1)<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByEingeflossenInErgebnis( @javax.annotation.Nonnull de.ivu.elect.business.ergebnis.entity.Ergebnis ergebnis) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.ergebnis.entity.Ergebnis ergebnisCheckedAndAttached =  checkAndAttach(ergebnis, de.ivu.elect.business.ergebnis.entity.Ergebnis.class, "ergebnis"); ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.EingeflossenInErgebnis")
                              .setParameter(1, ergebnisCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByEingeflossenInErgebnis - NonUniqueResultException, Parameter: "
           + ", ergebnis:'"+ergebnis+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByEingeflossenInErgebnis(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: ErgebnissequenznummerIsNullNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT o FROM Ergebniseingang o WHERE o.ergebnissequenznummer IS NulL<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByErgebnissequenznummerIsNull() {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.ErgebnissequenznummerIsNull")
                                                            .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByErgebnissequenznummerIsNull - NonUniqueResultException, Parameter: "
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByErgebnissequenznummerIsNull(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: GebietAndErgebniseingangsartAndErgebniseingangstufeNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet = ?1 AND e.ergebniseingangsart = ?2 AND e.ergebniseingabestufe IN(?3)<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByGebietAndErgebniseingangsartAndErgebniseingangstufe( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufen) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufenCheckedAndAttached =  ergebniseingabestufen ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.GebietAndErgebniseingangsartAndErgebniseingangstufe")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                        .setParameter(3, ergebniseingabestufenCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByGebietAndErgebniseingangsartAndErgebniseingangstufe - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
           + ", ergebniseingabestufen:'"+ergebniseingabestufen+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByGebietAndErgebniseingangsartAndErgebniseingangstufe(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: GebietUndErgebniseingangsartNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet = ?1 AND e.ergebniseingangsart = ?2<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByGebietUndErgebniseingangsart( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.GebietUndErgebniseingangsart")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByGebietUndErgebniseingangsart - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByGebietUndErgebniseingangsart - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByGebietUndErgebniseingangsart(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: MaxEingangssequenznummerByWahlEingangsArtNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT MAX(e.eingangssequenznummer) FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsart = ?2<br>
      * SQL: <br>
      */
     public java.lang.Long findByMaxEingangssequenznummerByWahlEingangsArt( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.MaxEingangssequenznummerByWahlEingangsArt")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                                                      .getSingleResult();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByMaxEingangssequenznummerByWahlEingangsArt - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByMaxEingangssequenznummerByWahlEingangsArt - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByMaxEingangssequenznummerByWahlEingangsArt(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: MaxEingangssequenznummerNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT MAX(e.eingangssequenznummer) FROM Ergebniseingang e<br>
      * SQL: <br>
      */
     public java.lang.Long findByMaxEingangssequenznummer() {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.MaxEingangssequenznummer")
                                                            .getSingleResult();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByMaxEingangssequenznummer - NonUniqueResultException, Parameter: "
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByMaxEingangssequenznummer(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: MaxErgebnissequenznummerByWahlUndErgebniseingangsartNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT MAX(e.ergebnissequenznummer) FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsart = ?2<br>
      * SQL: <br>
      */
     public java.lang.Long findByMaxErgebnissequenznummerByWahlUndErgebniseingangsart( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.MaxErgebnissequenznummerByWahlUndErgebniseingangsart")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                                                      .getSingleResult();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByMaxErgebnissequenznummerByWahlUndErgebniseingangsart - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByMaxErgebnissequenznummerByWahlUndErgebniseingangsart(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: MaxErgebnissequenznummerNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT MAX(e.ergebnissequenznummer) FROM Ergebniseingang e<br>
      * SQL: <br>
      */
     public java.lang.Long findByMaxErgebnissequenznummer() {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  
                              return
                    (java.lang.Long)
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.MaxErgebnissequenznummer")
                                                            .getSingleResult();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByMaxErgebnissequenznummer - NonUniqueResultException, Parameter: "
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByMaxErgebnissequenznummer(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeDbmsNoFlush<br>
      * Beschreibung: ELECT-6934 version für _echte_ DBMS mit allen Funktionen<br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsart = ?2 AND e.ergebniseingabestufe IN(?3) AND (e.wahldurchfuehrungsgebiet, e.eingangssequenznummer) IN (SELECT e2.wahldurchfuehrungsgebiet, MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet.wahl = ?1 AND e2.ergebniseingangsart = ?2 AND e2.ergebniseingabestufe IN(?3) GROUP BY e2.wahldurchfuehrungsgebiet)<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeDbms( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufen) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufenCheckedAndAttached =  ergebniseingabestufen ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeDbms")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                        .setParameter(3, ergebniseingabestufenCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeDbms - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeDbms - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
           + ", ergebniseingabestufen:'"+ergebniseingabestufen+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeDbms(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeH2NoFlush<br>
      * Beschreibung: ELECT-6934 Version für H2 und Derby, funktioniert, weil die einganzsequenznummer eindeutig ist<br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsart = ?2 AND e.ergebniseingabestufe IN(?3) AND e.eingangssequenznummer IN (SELECT MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet.wahl = ?1 AND e2.ergebniseingangsart = ?2 AND e2.ergebniseingabestufe IN(?3) GROUP BY e2.wahldurchfuehrungsgebiet)<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeH2( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufen) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufenCheckedAndAttached =  ergebniseingabestufen ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeH2")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                        .setParameter(3, ergebniseingabestufenCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeH2 - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeH2 - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
           + ", ergebniseingabestufen:'"+ergebniseingabestufen+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesteEingaengeByWahlAndErgebniseingangsartAndErgebniseingabestufeH2(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesteEingaengeByWahlAndErgebniseingangsartDbmsNoFlush<br>
      * Beschreibung: ELECT-6934 version für _echte_ DBMS mit allen Funktionen<br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsart = ?2 AND (e.wahldurchfuehrungsgebiet, e.eingangssequenznummer) IN (SELECT e2.wahldurchfuehrungsgebiet, MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet.wahl = ?1 AND e2.ergebniseingangsart = ?2 GROUP BY e2.wahldurchfuehrungsgebiet)<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesteEingaengeByWahlAndErgebniseingangsartDbms( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesteEingaengeByWahlAndErgebniseingangsartDbms")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByNeuesteEingaengeByWahlAndErgebniseingangsartDbms - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesteEingaengeByWahlAndErgebniseingangsartDbms - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesteEingaengeByWahlAndErgebniseingangsartDbms(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesteEingaengeByWahlAndErgebniseingangsartH2NoFlush<br>
      * Beschreibung: ELECT-6934 Version für H2 und Derby, funktioniert, weil die einganzsequenznummer eindeutig ist<br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsart = ?2 AND e.eingangssequenznummer IN (SELECT MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet.wahl = ?1 AND e2.ergebniseingangsart = ?2 GROUP BY e2.wahldurchfuehrungsgebiet)<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesteEingaengeByWahlAndErgebniseingangsartH2( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesteEingaengeByWahlAndErgebniseingangsartH2")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByNeuesteEingaengeByWahlAndErgebniseingangsartH2 - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesteEingaengeByWahlAndErgebniseingangsartH2 - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesteEingaengeByWahlAndErgebniseingangsartH2(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesterEingangByGebietAndErgebniseingangsartAndErgebniseingabestufeNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.eingangssequenznummer = ( SELECT MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet = ?1 AND e2.ergebniseingangsart IN(?2) AND e2.ergebniseingabestufe IN(?3))<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesterEingangByGebietAndErgebniseingangsartAndErgebniseingabestufe( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsarten,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufen) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsartenCheckedAndAttached =  ergebniseingangsarten ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufenCheckedAndAttached =  ergebniseingabestufen ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesterEingangByGebietAndErgebniseingangsartAndErgebniseingabestufe")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartenCheckedAndAttached)
                                        .setParameter(3, ergebniseingabestufenCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesterEingangByGebietAndErgebniseingangsartAndErgebniseingabestufe - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
           + ", ergebniseingangsarten:'"+ergebniseingangsarten+"'"
           + ", ergebniseingabestufen:'"+ergebniseingabestufen+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesterEingangByGebietAndErgebniseingangsartAndErgebniseingabestufe(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatusAndErgebniseingabestufeNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.eingangssequenznummer = ( SELECT MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet = ?1 AND e2.ergebniseingangsart IN (?2) AND e2.ergebniseingangsfehlerstatus IN (?3) AND e2.ergebniseingabestufe IN(?4))<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatusAndErgebniseingabestufe( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsarten,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatus,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufen) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsartenCheckedAndAttached =  ergebniseingangsarten ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatusCheckedAndAttached =  ergebniseingangsfehlerstatus ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingabestufe> ergebniseingabestufenCheckedAndAttached =  ergebniseingabestufen ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatusAndErgebniseingabestufe")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartenCheckedAndAttached)
                                        .setParameter(3, ergebniseingangsfehlerstatusCheckedAndAttached)
                                        .setParameter(4, ergebniseingabestufenCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatusAndErgebniseingabestufe - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
           + ", ergebniseingangsarten:'"+ergebniseingangsarten+"'"
           + ", ergebniseingangsfehlerstatus:'"+ergebniseingangsfehlerstatus+"'"
           + ", ergebniseingabestufen:'"+ergebniseingabestufen+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatusAndErgebniseingabestufe(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatusNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.eingangssequenznummer = ( SELECT MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet = ?1 AND e2.ergebniseingangsart IN (?2) AND e2.ergebniseingangsfehlerstatus IN (?3))<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatus( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsarten,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatus) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsartenCheckedAndAttached =  ergebniseingangsarten ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatusCheckedAndAttached =  ergebniseingangsfehlerstatus ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatus")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartenCheckedAndAttached)
                                        .setParameter(3, ergebniseingangsfehlerstatusCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatus - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
           + ", ergebniseingangsarten:'"+ergebniseingangsarten+"'"
           + ", ergebniseingangsfehlerstatus:'"+ergebniseingangsfehlerstatus+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesterEingangByGebietAndErgebniseingangsartAndFehlerstatus(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: NeuesterEingangByGebietAndErgebniseingangsartNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.eingangssequenznummer = ( SELECT MAX(e2.eingangssequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet = ?1 AND e2.ergebniseingangsart IN(?2))<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByNeuesterEingangByGebietAndErgebniseingangsart( @javax.annotation.Nonnull de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebiet,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsarten) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet wahldurchfuehrungsgebietCheckedAndAttached =  checkAndAttach(wahldurchfuehrungsgebiet, de.ivu.elect.business.gebietsbaum.entity.Wahldurchfuehrungsgebiet.class, "wahldurchfuehrungsgebiet"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart> ergebniseingangsartenCheckedAndAttached =  ergebniseingangsarten ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.NeuesterEingangByGebietAndErgebniseingangsart")
                              .setParameter(1, wahldurchfuehrungsgebietCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartenCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByNeuesterEingangByGebietAndErgebniseingangsart - NonUniqueResultException, Parameter: "
           + ", wahldurchfuehrungsgebiet:'"+wahldurchfuehrungsgebiet+"'"
           + ", ergebniseingangsarten:'"+ergebniseingangsarten+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByNeuesterEingangByGebietAndErgebniseingangsart(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: WahlArtenStatusErgebnissequenznummerZwischenNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsart = ?2 AND e.ergebniseingangsfehlerstatus IN(?3) AND e.ergebnissequenznummer <= ?4 AND e.ergebnissequenznummer>=?5 AND e.ergebnissequenznummer = ( SELECT MAX(e2.ergebnissequenznummer) FROM Ergebniseingang e2 WHERE e2.wahldurchfuehrungsgebiet = e.wahldurchfuehrungsgebiet AND e2.ergebniseingangsart = ?2 AND e2.ergebniseingangsfehlerstatus IN(?3) AND e2.ergebnissequenznummer <= ?4 AND e2.ergebnissequenznummer>=?5)<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByWahlArtenStatusErgebnissequenznummerZwischen( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsart,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatus,  @javax.annotation.Nonnull java.lang.Long maximaleErgebnissequenznummer,  @javax.annotation.Nonnull java.lang.Long minimaleErgebnissequenznummer) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart ergebniseingangsartCheckedAndAttached =  checkAndAttach(ergebniseingangsart, de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsart.class, "ergebniseingangsart"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatusCheckedAndAttached =  ergebniseingangsfehlerstatus ;
		  			  java.lang.Long maximaleErgebnissequenznummerCheckedAndAttached =  maximaleErgebnissequenznummer ;
		  			  java.lang.Long minimaleErgebnissequenznummerCheckedAndAttached =  minimaleErgebnissequenznummer ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.WahlArtenStatusErgebnissequenznummerZwischen")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsartCheckedAndAttached)
                                        .setParameter(3, ergebniseingangsfehlerstatusCheckedAndAttached)
                                        .setParameter(4, maximaleErgebnissequenznummerCheckedAndAttached)
                                        .setParameter(5, minimaleErgebnissequenznummerCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByWahlArtenStatusErgebnissequenznummerZwischen - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsart:'"+ergebniseingangsart+"'"
           + ", ergebniseingangsfehlerstatus:'"+ergebniseingangsfehlerstatus+"'"
           + ", maximaleErgebnissequenznummer:'"+maximaleErgebnissequenznummer+"'"
           + ", minimaleErgebnissequenznummer:'"+minimaleErgebnissequenznummer+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByWahlArtenStatusErgebnissequenznummerZwischen(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: WahlFehlerstatusUndErgebnissequenznummerZwischenNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.ergebnissequenznummer <= ?3 AND e.ergebnissequenznummer>=?4 AND e.wahldurchfuehrungsgebiet.wahl = ?1 AND e.ergebniseingangsfehlerstatus IN ?2<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByWahlFehlerstatusUndErgebnissequenznummerZwischen( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl,  @javax.annotation.Nonnull java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatus,  @javax.annotation.Nonnull java.lang.Long maximaleErgebnissequenznummer,  @javax.annotation.Nonnull java.lang.Long minimaleErgebnissequenznummer) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

            try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  			  java.util.Collection<de.ivu.elect.business.stimmeingabe.entity.Ergebniseingangsfehlerstatus> ergebniseingangsfehlerstatusCheckedAndAttached =  ergebniseingangsfehlerstatus ;
		  			  java.lang.Long maximaleErgebnissequenznummerCheckedAndAttached =  maximaleErgebnissequenznummer ;
		  			  java.lang.Long minimaleErgebnissequenznummerCheckedAndAttached =  minimaleErgebnissequenznummer ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.WahlFehlerstatusUndErgebnissequenznummerZwischen")
                              .setParameter(1, wahlCheckedAndAttached)
                                        .setParameter(2, ergebniseingangsfehlerstatusCheckedAndAttached)
                                        .setParameter(3, maximaleErgebnissequenznummerCheckedAndAttached)
                                        .setParameter(4, minimaleErgebnissequenznummerCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByWahlFehlerstatusUndErgebnissequenznummerZwischen - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
           + ", ergebniseingangsfehlerstatus:'"+ergebniseingangsfehlerstatus+"'"
           + ", maximaleErgebnissequenznummer:'"+maximaleErgebnissequenznummer+"'"
           + ", minimaleErgebnissequenznummer:'"+minimaleErgebnissequenznummer+"'"
    
        );
    throw nure;
        }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByWahlFehlerstatusUndErgebnissequenznummerZwischen(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }

     /**
      * Name: WahlNoFlush<br>
      * Beschreibung: <br>
      * EJBQL: SELECT e FROM Ergebniseingang e WHERE e.wahldurchfuehrungsgebiet.wahl = ?1<br>
      * SQL: <br>
      */
     public java.util.List<Ergebniseingang> findByWahl( @javax.annotation.Nonnull de.ivu.elect.business.wahl.entity.Wahl wahl) {
            long start = 0L;

            if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
               start = System.currentTimeMillis();
            }

    try {

        int versuch = 0;
      while (true) {
        versuch++;
                try {

          		  			  de.ivu.elect.business.wahl.entity.Wahl wahlCheckedAndAttached =  checkAndAttach(wahl, de.ivu.elect.business.wahl.entity.Wahl.class, "wahl"); ;
		  
                              return
                              getEntityManager().
                                createNamedQuery("ERGEBNISEINGANG.Wahl")
                              .setParameter(1, wahlCheckedAndAttached)
                                                                      .getResultList();
                                        
                    
        } catch (EntityNotFoundException enfe) {
      // ELECTMUC-2455
       if (de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.INVALIDATE_CACHE &&
       versuch < de.ivu.elect.business.system.control.InvalidateCacheOnEntityNotFound.MAX_VERSUCHE ) {
       LOG.warn("findByWahl - EntityNotFoundException: " +enfe.getMessage()+", Versuch: " +versuch+" - lösche Cache - wiederhole");
        try {
         de.ivu.elect.business.system.boundary.CacheResetSession.reset(getEntityManager());
        } catch (Exception e) {
          LOG.warn("Fehler beim Zurücksetzen des Cache: "+e.getMessage());

        }
       } else {
        throw enfe;
       }
           } catch (NonUniqueResultException nure) {
    LOG.warn("Ergebniseingang, findByWahl - NonUniqueResultException, Parameter: "
           + ", wahl:'"+wahl+"'"
    
        );
    throw nure;
            }
            }

    } finally {
    if (de.ivu.elect.business.system.control.LogQueries.LOG_QUERIES) {
    LOG.info("Query: " + getClass().getName()+".findByWahl(): "+(System.currentTimeMillis()-start)+ " ms");
    }
    }
     }



  @Override
  public boolean isEntityWithUKPresent(de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangUK uk) {
    try {
      return findByUK(uk) != null;
    } catch (javax.persistence.NoResultException nre) {
      return false;
    }
  }

  @Override
  public boolean isEntityWithUKHasPK(de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangUK uk,
        de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangPK
      pk

  ) {
    try {
      return findByUK(uk).getPk().equals(pk);
    } catch (NoResultException ignored) {
      // Do nothing - be happy.
    }
    return true;
  }

    public de.ivu.elect.business.stimmeingabe.entity.Ergebniseingang findByUK(de.ivu.elect.business.stimmeingabe.entity.ErgebniseingangUK uk){
        throw new UnsupportedOperationException("Kein UK definiert");
    }


}