Package de.trustable.ca3s.core.repository

Interface CertificateRepository

All Superinterfaces:

org.springframework.data.repository.CrudRepository<Certificate,Long>, org.springframework.data.jpa.repository.JpaRepository<Certificate,Long>, org.springframework.data.repository.PagingAndSortingRepository<Certificate,Long>, org.springframework.data.repository.query.QueryByExampleExecutor<Certificate>, org.springframework.data.repository.Repository<Certificate,Long>

@Repository("certificateRepository")
public interface CertificateRepository
extends org.springframework.data.jpa.repository.JpaRepository<Certificate,Long>

Spring Data repository for the Certificate entity.

Method Summary

Modifier and Type	Method	Description
List<Certificate>	findActiveByAttributeValue(String name, String value)
List<Certificate>	findActiveCertificateBySerial(String serial)
List<Object[]>	findActiveCertificateOrderedByCrlURL()
List<Object[]>	findActiveCertificatesByHashAlgo(Instant now)
List<Object[]>	findActiveCertificatesByKeyAlgo(Instant now)
List<Object[]>	findActiveCertificatesByKeyLength(Instant now)
org.springframework.data.domain.Page<Certificate>	findActiveCertificatesBySANs(org.springframework.data.domain.Pageable pageable, Instant now, List<String> sans)
List<Certificate>	findActiveCertificatesByValidTo(Instant now)
List<Certificate>	findActiveTLSCertificate()
List<Certificate>	findByAttributeValue(String name, String value)
org.springframework.data.domain.Page<Certificate>	findByAttributeValueLowerThan(org.springframework.data.domain.Pageable pageable, String name, String value)
List<Certificate>	findByIssuerSerial(String issuer, String serial)
List<Certificate>	findByRequestor(String requestor)
List<Certificate>	findBySearchTermNamed1(String name, String value)
org.springframework.data.domain.Page<Certificate>	findBySearchTermNamed1(org.springframework.data.domain.Pageable pageable, String name, String value)
List<Certificate>	findBySearchTermNamed2(String name1, String value1, String name2, String value2)
org.springframework.data.domain.Page<Certificate>	findBySearchTermNamed2(org.springframework.data.domain.Pageable pageable, String name1, String value1, String name2, String value2)
List<Certificate>	findByTBSDigest(String tbsDigest)
List<Certificate>	findByTermNamed2(String name1, String value1, String name2, String value2)
List<Certificate>	findByValidTo(Instant after, Instant before)
List<Certificate>	findCACertByIssuer(String issuer)
List<String>	findCrlURLForActiveCertificates()
List<Certificate>	findInactiveCertificatesByValidFrom(Instant now)
String	findMaxTimestampForCA(String caName, String timestamp)
List<Certificate>	findNonRevokedByTypeAndValidTo(boolean isEndEntity, Instant after, Instant before)
List<Certificate>	findTimestampNotExistForCA(String caName, String timestamp)

Methods inherited from interface org.springframework.data.repository.CrudRepository

count, delete, deleteAll, deleteAll, deleteAllById, deleteById, existsById, findById, save

Methods inherited from interface org.springframework.data.jpa.repository.JpaRepository

deleteAllByIdInBatch, deleteAllInBatch, deleteAllInBatch, deleteInBatch, findAll, findAll, findAll, findAll, findAllById, flush, getById, getOne, getReferenceById, saveAll, saveAllAndFlush, saveAndFlush

Methods inherited from interface org.springframework.data.repository.PagingAndSortingRepository

findAll

Methods inherited from interface org.springframework.data.repository.query.QueryByExampleExecutor

count, exists, findAll, findBy, findOne

Method Detail

findByIssuerSerial

@Query(name="Certificate.findByIssuerSerial")
List<Certificate> findByIssuerSerial(@Param("issuer")
                                     String issuer,
                                     @Param("serial")
                                     String serial)

findCACertByIssuer

@Query(name="Certificate.findCACertByIssuer")
List<Certificate> findCACertByIssuer(@Param("issuer")
                                     String issuer)

findBySearchTermNamed1

@Query(name="Certificate.findBySearchTermNamed1")
org.springframework.data.domain.Page<Certificate> findBySearchTermNamed1(org.springframework.data.domain.Pageable pageable,
                                                                         @Param("name")
                                                                         String name,
                                                                         @Param("value")
                                                                         String value)

findBySearchTermNamed1

@Query(name="Certificate.findBySearchTermNamed1")
List<Certificate> findBySearchTermNamed1(@Param("name")
                                         String name,
                                         @Param("value")
                                         String value)

findByAttributeValueLowerThan

@Query(name="Certificate.findByAttributeValueLowerThan")
org.springframework.data.domain.Page<Certificate> findByAttributeValueLowerThan(org.springframework.data.domain.Pageable pageable,
                                                                                @Param("name")
                                                                                String name,
                                                                                @Param("value")
                                                                                String value)

findBySearchTermNamed2

@Query(name="Certificate.findBySearchTermNamed2")
org.springframework.data.domain.Page<Certificate> findBySearchTermNamed2(org.springframework.data.domain.Pageable pageable,
                                                                         @Param("name1")
                                                                         String name1,
                                                                         @Param("value1")
                                                                         String value1,
                                                                         @Param("name2")
                                                                         String name2,
                                                                         @Param("value2")
                                                                         String value2)

findBySearchTermNamed2

@Query(name="Certificate.findBySearchTermNamed2")
List<Certificate> findBySearchTermNamed2(@Param("name1")
                                         String name1,
                                         @Param("value1")
                                         String value1,
                                         @Param("name2")
                                         String name2,
                                         @Param("value2")
                                         String value2)

findByTermNamed2

@Query(name="Certificate.findByTermNamed2")
List<Certificate> findByTermNamed2(@Param("name1")
                                   String name1,
                                   @Param("value1")
                                   String value1,
                                   @Param("name2")
                                   String name2,
                                   @Param("value2")
                                   String value2)

findActiveByAttributeValue

@Query(name="Certificate.findActiveByAttributeValue")
List<Certificate> findActiveByAttributeValue(@Param("name")
                                             String name,
                                             @Param("value")
                                             String value)

findByAttributeValue

@Query(name="Certificate.findByAttributeValue")
List<Certificate> findByAttributeValue(@Param("name")
                                       String name,
                                       @Param("value")
                                       String value)

findByTBSDigest

@Query(name="Certificate.findByTBSDigest")
List<Certificate> findByTBSDigest(@Param("tbsDigest")
                                  String tbsDigest)

findByValidTo

@Query(name="Certificate.findByValidTo")
List<Certificate> findByValidTo(@Param("after")
                                Instant after,
                                @Param("before")
                                Instant before)

findNonRevokedByTypeAndValidTo

@Query(name="Certificate.findNonRevokedByTypeAndValidTo")
List<Certificate> findNonRevokedByTypeAndValidTo(@Param("isEndEntity")
                                                 boolean isEndEntity,
                                                 @Param("after")
                                                 Instant after,
                                                 @Param("before")
                                                 Instant before)

findActiveCertificatesByHashAlgo

@Query(name="Certificate.findActiveCertificatesByHashAlgo")
List<Object[]> findActiveCertificatesByHashAlgo(@Param("now")
                                                Instant now)

findActiveCertificatesByKeyAlgo

@Query(name="Certificate.findActiveCertificatesByKeyAlgo")
List<Object[]> findActiveCertificatesByKeyAlgo(@Param("now")
                                               Instant now)

findActiveCertificatesByKeyLength

@Query(name="Certificate.findActiveCertificatesByKeyLength")
List<Object[]> findActiveCertificatesByKeyLength(@Param("now")
                                                 Instant now)

findInactiveCertificatesByValidFrom

@Query(name="Certificate.findInactiveCertificatesByValidFrom")
List<Certificate> findInactiveCertificatesByValidFrom(@Param("now")
                                                      Instant now)

findActiveCertificatesByValidTo

@Query(name="Certificate.findActiveCertificatesByValidTo")
List<Certificate> findActiveCertificatesByValidTo(@Param("now")
                                                  Instant now)

findActiveCertificatesBySANs

@Query(name="Certificate.findActiveCertificatesBySANs")
org.springframework.data.domain.Page<Certificate> findActiveCertificatesBySANs(org.springframework.data.domain.Pageable pageable,
                                                                               @Param("now")
                                                                               Instant now,
                                                                               @Param("sans")
                                                                               List<String> sans)

findActiveCertificateOrderedByCrlURL

@Query(name="Certificate.findActiveCertificateOrderedByCrlURL")
List<Object[]> findActiveCertificateOrderedByCrlURL()

findCrlURLForActiveCertificates

@Query(name="Certificate.findCrlURLForActiveCertificates")
List<String> findCrlURLForActiveCertificates()

findActiveCertificateBySerial

@Query(name="Certificate.findActiveCertificateBySerial")
List<Certificate> findActiveCertificateBySerial(@Param("serial")
                                                String serial)

findTimestampNotExistForCA

@Query(name="Certificate.findTimestampNotExistForCA")
List<Certificate> findTimestampNotExistForCA(@Param("caName")
                                             String caName,
                                             @Param("timestamp")
                                             String timestamp)

findMaxTimestampForCA

@Query(name="Certificate.findMaxTimestampForCA")
String findMaxTimestampForCA(@Param("caName")
                             String caName,
                             @Param("timestamp")
                             String timestamp)

findActiveTLSCertificate

@Query(name="Certificate.findActiveTLSCertificate")
List<Certificate> findActiveTLSCertificate()

findByRequestor

@Query(name="Certificate.findByRequestor")
List<Certificate> findByRequestor(@Param("requestor")
                                  String requestor)