org.egov.infra.admin.master.repository

Interface BoundaryRepository

All Superinterfaces:

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

@Repository
public interface BoundaryRepository
extends org.springframework.data.jpa.repository.JpaRepository<Boundary,Long>

Method Summary

Modifier and Type	Method and Description
List<Boundary>	findActiveBoundariesByBndryTypeNameAndHierarchyTypeName(String boundaryTypeName, String hierarchyTypeName)
List<Boundary>	findActiveBoundariesByBoundaryTypeId(Long boundaryTypeId)
List<Boundary>	findActiveBoundariesByHierarchyTypeAndLevelAndAsOnDate(HierarchyType hierarchyType, Long hierarchyLevel, Date asOnDate)
List<Boundary>	findActiveBoundariesByNameAndBndryTypeNameAndHierarchyTypeName(String boundaryTypeName, String hierarchyTypeName, String name)
List<Boundary>	findActiveBoundariesForMpath(Set<String> mpath)
Boundary	findActiveBoundaryByBndryNumAndTypeAndHierarchyTypeCodeAndAsOnDate(Long boundaryNum, String boundaryType, String hierarchyTypeCode, Date asOnDate)
List<Boundary>	findActiveChildBoundariesByBoundaryIdAndAsOnDate(Long parentBoundaryId, Date asOnDate)
List<Boundary>	findActiveChildrenWithParent(Long parentId)
List<Boundary>	findActiveImmediateChildrenWithOutParent(Long parentId)
List<Boundary>	findAllParents()
Boundary	findBoundarieByBoundaryTypeAndBoundaryNum(BoundaryType boundaryType, Long boundaryNum)
List<Boundary>	findBoundariesByBndryTypeNameAndHierarchyTypeName(String boundaryTypeName, String hierarchyTypeName)
List<Boundary>	findBoundariesByBoundaryType(Long boundaryTypeId)
Boundary	findBoundaryByBndryTypeNameAndHierarchyTypeName(String boundaryTypeName, String hierarchyTypeName)
Boundary	findByBoundaryTypeNameAndHierarchyTypeNameAndLevel(String boundaryType, String hierarchyType, Long hierarchyLevel)
List<Boundary>	findByBoundaryTypeOrderByBoundaryNumAsc(BoundaryType boundaryType)
Boundary	findByName(String name)
List<Boundary>	findByNameAndBoundaryTypeOrderByBoundaryNumAsc(String boundaryName, Long boundaryTypeId)
List<Boundary>	findByNameContainingIgnoreCase(String name)
List<Boundary>	findChildBoundariesByBoundaryIdAndAsOnDate(Long parentBoundaryId, Date asOnDate)

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

deleteAllInBatch, deleteInBatch, findAll, findAll, findAll, findAll, findAll, flush, getOne, save, saveAndFlush

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

findAll

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

count, delete, delete, delete, deleteAll, exists, findOne, save

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

count, exists, findAll, findOne

Method Detail

findByName

@QueryHints(value=)
Boundary findByName(String name)

findByNameContainingIgnoreCase

List<Boundary> findByNameContainingIgnoreCase(String name)

findBoundariesByBoundaryType

List<Boundary> findBoundariesByBoundaryType(@Param(value="boundaryTypeId")
                                            Long boundaryTypeId)

findBoundarieByBoundaryTypeAndBoundaryNum

Boundary findBoundarieByBoundaryTypeAndBoundaryNum(@Param(value="boundaryType")
                                                   BoundaryType boundaryType,
                                                   @Param(value="boundaryNum")
                                                   Long boundaryNum)

findActiveBoundariesByBoundaryTypeId

@Query(value="select b from Boundary b where b.isHistory=false AND b.boundaryType.id =:boundaryTypeId order by b.name")
List<Boundary> findActiveBoundariesByBoundaryTypeId(@Param(value="boundaryTypeId")
                                                                                                                                                                            Long boundaryTypeId)

findActiveBoundariesByHierarchyTypeAndLevelAndAsOnDate

@Query(value="select b from Boundary b where b.isHistory=false AND b.boundaryType.hierarchyType = :hierarchyType AND b.boundaryType.hierarchy = :hierarchyLevel AND ((b.toDate IS NULL AND b.fromDate <= :asOnDate) OR (b.toDate IS NOT NULL AND b.fromDate <= :asOnDate AND b.toDate >= :asOnDate)) order by b.name")
List<Boundary> findActiveBoundariesByHierarchyTypeAndLevelAndAsOnDate(@Param(value="hierarchyType")
                                                                                                                                                                                                                                                                                                                                                                                             HierarchyType hierarchyType,
                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="hierarchyLevel")
                                                                                                                                                                                                                                                                                                                                                                                             Long hierarchyLevel,
                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="asOnDate")
                                                                                                                                                                                                                                                                                                                                                                                             Date asOnDate)

findActiveChildBoundariesByBoundaryIdAndAsOnDate

@Query(value="select b from Boundary b where b.isHistory=false AND b.parent is not null AND b.parent.id = :parentBoundaryId AND ((b.toDate IS NULL AND b.fromDate <= :asOnDate) OR (b.toDate IS NOT NULL AND b.fromDate <= :asOnDate AND b.toDate >= :asOnDate)) order by b.name")
List<Boundary> findActiveChildBoundariesByBoundaryIdAndAsOnDate(@Param(value="parentBoundaryId")
                                                                                                                                                                                                                                                                                                                                                   Long parentBoundaryId,
                                                                                                                                                                                                                                                                                                                                                   @Param(value="asOnDate")
                                                                                                                                                                                                                                                                                                                                                   Date asOnDate)

findActiveChildrenWithParent

@Query(value="from Boundary BND where BND.isHistory=false AND BND.materializedPath like (select B.materializedPath from Boundary B where B.id=:parentId)||\'%\'")
List<Boundary> findActiveChildrenWithParent(@Param(value="parentId")
                                                                                                                                                                                                              Long parentId)

findActiveBoundariesForMpath

@Query(value="from Boundary BND where BND.isHistory=false AND BND.materializedPath in :mpath ")
List<Boundary> findActiveBoundariesForMpath(@Param(value="mpath")
                                                                                                                                            Set<String> mpath)

findChildBoundariesByBoundaryIdAndAsOnDate

@Query(value="select b from Boundary b where b.parent is not null AND b.parent.id = :parentBoundaryId AND ((b.toDate IS NULL AND b.fromDate <= :asOnDate) OR (b.toDate IS NOT NULL AND b.fromDate <= :asOnDate AND b.toDate >= :asOnDate)) order by b.name")
List<Boundary> findChildBoundariesByBoundaryIdAndAsOnDate(@Param(value="parentBoundaryId")
                                                                                                                                                                                                                                                                                                                       Long parentBoundaryId,
                                                                                                                                                                                                                                                                                                                       @Param(value="asOnDate")
                                                                                                                                                                                                                                                                                                                       Date asOnDate)

findActiveBoundaryByBndryNumAndTypeAndHierarchyTypeCodeAndAsOnDate

@Query(value="select b from Boundary b where b.isHistory=false AND b.boundaryNum = :boundaryNum AND b.boundaryType.name = :boundaryType AND upper(b.boundaryType.hierarchyType.code) = :hierarchyTypeCode AND ((b.toDate IS NULL AND b.fromDate <= :asOnDate) OR (b.toDate IS NOT NULL AND b.fromDate <= :asOnDate AND b.toDate >= :asOnDate))")
Boundary findActiveBoundaryByBndryNumAndTypeAndHierarchyTypeCodeAndAsOnDate(@Param(value="boundaryNum")
                                                                                                                                                                                                                                                                                                                                                                                                                             Long boundaryNum,
                                                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="boundaryType")
                                                                                                                                                                                                                                                                                                                                                                                                                             String boundaryType,
                                                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="hierarchyTypeCode")
                                                                                                                                                                                                                                                                                                                                                                                                                             String hierarchyTypeCode,
                                                                                                                                                                                                                                                                                                                                                                                                                             @Param(value="asOnDate")
                                                                                                                                                                                                                                                                                                                                                                                                                             Date asOnDate)

findActiveBoundariesByBndryTypeNameAndHierarchyTypeName

@Query(value="select b from Boundary b where b.isHistory=false AND upper(b.boundaryType.name) = upper(:boundaryTypeName) AND upper(b.boundaryType.hierarchyType.name) = upper(:hierarchyTypeName) order by b.name")
List<Boundary> findActiveBoundariesByBndryTypeNameAndHierarchyTypeName(@Param(value="boundaryTypeName")
                                                                                                                                                                                                                                                                                           String boundaryTypeName,
                                                                                                                                                                                                                                                                                           @Param(value="hierarchyTypeName")
                                                                                                                                                                                                                                                                                           String hierarchyTypeName)

findBoundariesByBndryTypeNameAndHierarchyTypeName

@Query(value="select b from Boundary b where upper(b.boundaryType.name) = UPPER(:boundaryTypeName) AND upper(b.boundaryType.hierarchyType.name) = UPPER(:hierarchyTypeName) order by b.id")
List<Boundary> findBoundariesByBndryTypeNameAndHierarchyTypeName(@Param(value="boundaryTypeName")
                                                                                                                                                                                                                                                             String boundaryTypeName,
                                                                                                                                                                                                                                                             @Param(value="hierarchyTypeName")
                                                                                                                                                                                                                                                             String hierarchyTypeName)

findBoundaryByBndryTypeNameAndHierarchyTypeName

@Query(value="select b from Boundary b where upper(b.boundaryType.name) = UPPER(:boundaryTypeName) AND upper(b.boundaryType.hierarchyType.name) = UPPER(:hierarchyTypeName) order by b.id")
Boundary findBoundaryByBndryTypeNameAndHierarchyTypeName(@Param(value="boundaryTypeName")
                                                                                                                                                                                                                                                     String boundaryTypeName,
                                                                                                                                                                                                                                                     @Param(value="hierarchyTypeName")
                                                                                                                                                                                                                                                     String hierarchyTypeName)

findByNameAndBoundaryTypeOrderByBoundaryNumAsc

@Query(value="select b from Boundary b where b.isHistory=false and UPPER(b.name) like UPPER(:boundaryName) and b.boundaryType.id=:boundaryTypeId order by b.boundaryNum asc")
List<Boundary> findByNameAndBoundaryTypeOrderByBoundaryNumAsc(@Param(value="boundaryName")
                                                                                                                                                                                                                                            String boundaryName,
                                                                                                                                                                                                                                            @Param(value="boundaryTypeId")
                                                                                                                                                                                                                                            Long boundaryTypeId)

findByBoundaryTypeNameAndHierarchyTypeNameAndLevel

@Query(value="select b from Boundary b where b.boundaryType.name=:boundaryType and b.boundaryType.hierarchyType.name=:hierarchyType and b.boundaryType.hierarchy=:hierarchyLevel")
Boundary findByBoundaryTypeNameAndHierarchyTypeNameAndLevel(@Param(value="boundaryType")
                                                                                                                                                                                                                                               String boundaryType,
                                                                                                                                                                                                                                               @Param(value="hierarchyType")
                                                                                                                                                                                                                                               String hierarchyType,
                                                                                                                                                                                                                                               @Param(value="hierarchyLevel")
                                                                                                                                                                                                                                               Long hierarchyLevel)

findActiveBoundariesByNameAndBndryTypeNameAndHierarchyTypeName

@Query(value="select b from Boundary b where b.isHistory=false AND upper(b.boundaryType.name) = upper(:boundaryTypeName) AND upper(b.boundaryType.hierarchyType.name) = upper(:hierarchyTypeName) AND UPPER(b.name) like UPPER(:name)||\'%\' order by b.id")
List<Boundary> findActiveBoundariesByNameAndBndryTypeNameAndHierarchyTypeName(@Param(value="boundaryTypeName")
                                                                                                                                                                                                                                                                                                                                           String boundaryTypeName,
                                                                                                                                                                                                                                                                                                                                           @Param(value="hierarchyTypeName")
                                                                                                                                                                                                                                                                                                                                           String hierarchyTypeName,
                                                                                                                                                                                                                                                                                                                                           @Param(value="name")
                                                                                                                                                                                                                                                                                                                                           String name)

findActiveImmediateChildrenWithOutParent

@Query(value="from Boundary BND where BND.isHistory=false AND BND.parent.id=:parentId)")
List<Boundary> findActiveImmediateChildrenWithOutParent(@Param(value="parentId")
                                                                                                                                                 Long parentId)

findAllParents

@Query(value="from Boundary BND where BND.parent is null")
List<Boundary> findAllParents()

findByBoundaryTypeOrderByBoundaryNumAsc

List<Boundary> findByBoundaryTypeOrderByBoundaryNumAsc(BoundaryType boundaryType)