Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.repository;

import com.spice.profitmandi.common.exception.ProfitMandiBusinessException;

import org.springframework.stereotype.Repository;

import org.springframework.util.MultiValueMap;

import javax.persistence.criteria.CriteriaBuilder;

import javax.persistence.criteria.Predicate;

import javax.persistence.criteria.Root;

import javax.swing.*;

import java.time.LocalDateTime;

import java.util.AbstractMap.SimpleEntry;

import java.util.List;

import java.util.Map;

import java.util.Set;

@Repository

public interface GenericRepository {

    public final String IS_NULL = "IS_NULL";

    public final String IS_NOT_NULL = "IS_NOT_NULL";

    public final String OR_MAP = "OR_MAP";

    public <T> void persist(Object object);

    public <T> void delete(Object object);

    public <T> List<T> selectAllOrderByDesc(Class<T> clazz, String orderByDescKey);

    public <T> List<T> selectAllOrderByAsc(Class<T> clazz, String orderByAscKey);

    public <T> long selectCount(Class<T> clazz);

    public <T> long selectCountByNotNull(Class<T> clazz, String notNullKey);

    public <T> long selectCountByEqual(Class<T> clazz, String key, Object value);

    public <T> long selectCountByEquals(Class<T> clazz, Map<String, Object> objectParams);

    public <T> long selectCountByIn(Class<T> clazz, String key, List<?> in);

    public <T> long selectCountByEqualBetween(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2);

    public <T> long selectCountByBetween(Class<T> clazz, String betweenKey, Object betweenValue1, Object betweenValue2);

    // public <T> List<T> selectAllPaginated(Class<T> clazz, int offset, int limit);

    public <T> List<T> selectAllOrderByDescPaginated(Class<T> clazz, String orderByDescKey, int offset, int limit);

    public <T> List<T> selectAllNotNullOrderByDescPaginated(Class<T> clazz, String notNullKey, String orderByDescKey, int offset, int limit);

    public <T> List<T> selectAllNotNullOrderByDesc(Class<T> clazz, String notNullKey, String orderByDescKey);

    public <T> T selectById(Class<T> clazz, int id);

    public <U, T> List<U> selectAllDistinctOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, String orderByDescKey);

    public <U, T> List<U> selectAllDistinctByNotInOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, List<?>> listParams, String orderByDescKey);

    public <T> List<T> selectAllByInsOrderByDesc(Class<T> clazz, Map<String, List<?>> listMap, String orderByDescKey);

    public <U, T> List<U> selectAllByInsOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, List<?>> listMap, String orderByDescKey);

    public <T> List<T> selectAllByInOrderByDesc(Class<T> clazz, String key, List<?> in, String orderByDescKey) throws ProfitMandiBusinessException;

    public <T> List<T> selectAllByInOrderByDescPaginated(Class<T> clazz, String key, List<?> in, String orderByDescKey, int offset, int limit);

    public <U, T> List<U> selectAllByInOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, String inKey, List<?> in, String orderByDescKey);

    public <T> List<T> selectAllByEqualsOrderByDesc(Class<T> clazz, Map<String, Object> objectMap, String orderByDescKey);

    public <U, T> List<U> selectAllByEqualsOrderBy(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, Object> objectMap, String orderByKey, SortOrder sortOrder);

    public <T> List<T> selectAllByEqualOrderByDesc(Class<T> clazz, String key, Object value, String orderByDescKey);

    public <T> List<T> selectAllByNotNull(Class<T> clazz, String notNullParams);

    public <T> T selectByNotNull(Class<T> clazz, String notNullKey);

    public <T> T selectByEqualNotNull(Class<T> clazz, String key, Object value, String notNullKey);

    // public <T> List<T> selectAllByEqualGtOrderByDesc(Class<T> clazz, String key,

    // Object value, String gtKey, Object gtValue, String orderByDescKey);

    public <T> List<T> selectAllByEqualOrderByDescPaginated(Class<T> clazz, String key, Object value, String orderByDescKey, int offset, int limit);

    public <T, U> List<U> selectAllByEqualOrderByDescPaginated(Class<T> clazz, Class<U> selector, String selectorKey, String key, Object value, String orderByDescKey, int offset, int limit);

    public <U, T> List<U> selectAllByEqualOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, String key, Object value, String orderByDescKey);

    public <T> List<T> selectAllByInsEqualsOrderBy(Class<T> clazz, Map<String, List<?>> listMap, Map<String, Object> objectMap, String orderByKey, SortOrder sortOrder);

    public <T> List<T> selectAllByInsEqualsGtOrderBy(Class<T> clazz, Map<String, List<?>> listMap, Map<String, Object> objectMap, String gtKey, Object gtValue, String orderByKey, SortOrder sortOrder);

    public <U, T> List<U> selectAllByInsEqualsOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, List<?>> listMap, Map<String, Object> objectMap, String orderByDescKey);

    public <T> List<T> selectAllByInEqualOrderByDesc(Class<T> clazz, String inKey, List<?> in, String key, Object value, String orderByDescKey);

    public <U, T> List<U> selectAllByInEqualOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, String inKey, List<?> in, String key, Object value, String orderByDescKey);

    public <T> List<T> selectAllByInEqualOrderBysDesc(Class<T> clazz, String inKey, List<?> in, String key, Object value, Set<String> orderBysDesc);

    public <T> List<T> selectAllByEqualGtOrderByDesc(Class<T> clazz, String key, Object value, String gtKey, Object gtValue, String orderByDescKey);

    public <T, U> List<U> selectAllByEqualGtOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, String key, Object value, String gtKey, Object gtValue, String orderByDescKey);

    public <T> List<T> selectAllByInsEqualsNullsOrderByDesc(Class<T> clazz, Map<String, List<?>> listMap, Map<String, Object> objectMap, Set<String> nullParams, String orderByDescKey);

    public <T> List<T> selectAllByEqualsNullNotNullGeLeOrderByDesc(Class<T> clazz, Map<String, Object> objectMap, Set<String> nullParams, Set<String> notNullParams, Map<String, Object> geParams, Map<String, Object> leParams, String orderByDescKey);

    public <T> T selectByNullNotNull(Class<T> clazz, String nullKey, String notNullKey);

    public <T> List<T> selectAllByEqualBetweenOrderByDesc(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String orderByDescKey);

    public <T> long selectCountByEqualsBetween(Class<T> clazz, Map<String, Object> objectParams, String betweenKey, Object betweenValue1, Object betweenValue2);

    public <T> double selectSumByEqualBetween(Class<T> clazz, String sumKey, Map<String, Object> objectParams, String betweenKey, Object betweenValue1, Object betweenValue2);

    public <T> List<T> selectAllByEqualBetweenOrderByDescPaginated(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String orderByDescKey, int offset, int limit);

    public <T> List<T> selectAllByInBetweenOrderByDesc(Class<T> clazz, String key, List<?> values, String betweenKey, Object betweenValue1, Object betweenValue2, String orderByDescKey);

    public <T> T selectByEquals(Class<T> clazz, Map<String, Object> objectMap);

    public <T> T selectFirstByEquals(Class<T> clazz, Map<String, Object> objectMap);

    public <T> List<T> selectAllByEqualsWithOrOrderByPaginated(Class<T> clazz, Map<String, Object> objectMap, String orderByDescKey, SortOrder sortOrder, int offset, int limit);

    public <T> List<T> selectAllByEqualsOrderByPaginated(Class<T> clazz, Map<String, Object> objectMap, String orderByDescKey, SortOrder sortOrder, int offset, int limit);

    public <T> T selectByEqual(Class<T> clazz, String key, Object value);

    public <T> List<T> selectByInEqualNullNotNull(Class<T> clazz, String inKey, List<?> inList, String equalKey, Object equalValue, String nullKey, String notNullKey);

    public <T> T selectByBetween(Class<T> clazz, String key, Object value1, Object value2);

    public <T> List<T> selectByBetweenList(Class<T> clazz, String key, Object value1, Object value2, int offset, int limit);

    public <U, T> U selectByBetween(Class<T> clazz, Class<U> selector, String selectorKey, String key, Object value1, Object value2);

    public <T> T selectByGeLe(Class<T> clazz, String geKey, Object geValue, String leKey, Object leValue, int offset);

    public <U, T> U selectByGeLe(Class<T> clazz, Class<U> selector, String selectorKey, String geKey, Object geValue, String leKey, Object leValue);

    public <T> List<T> selectAllByBetweenOrderByDesc(Class<T> clazz, String betweenKey, Object betweenValue1, Object betweenValue2, String orderByDescKey);

    <T> T selectById(Class<T> clazz, Long id);

    public <T> boolean isExistById(Class<T> clazz, int id);

    public <T> boolean isExistByEqual(Class<T> clazz, String key, Object value);

    public <T> boolean isExistByEquals(Class<T> clazz, Map<String, Object> objectMap);

    public <U, T> List<U> selectAllOrderByDesc(Class<T> clazz, Class<U> selector, String selectorKey, String orderByDescKey);

    public <U, T> List<U> selectAllOrderByDescPaginated(Class<T> clazz, Class<U> selector, String selectorKey, String orderByDescKey, int offset, int limit);

    public <T, V> List<T> selectAllByEqualBetweenWithJoinEqualOrderByDescPaginated(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, String joinKey, Object joinValue, String orderByDescKey, int offset, int limit);

    public <T, V> List<V> selectByEqualsWithJoinEqual(Class<T> clazz, Map<String, Object> objectParams, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, Object> joinEqualsMap);

    public <T, V> List<V> selectAllByEqualsWithJoinEqual(Class<T> clazz, Map<String, Object> objectParams, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, Object> joinEqualsMap);

    public <T, V, X> List<T> selectAllByEqualBetweenWithJoinJoinEqualOrderByDescPaginated(Class<T> clazz, String equalKey, Object equalValue, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz1, String joinClazz1Key, String joinClazz2Key, Class<X> joinClazz2, String join2Key, Object join2Value, String orderByDescKey, int offset, int limit);

    public <T, V> List<T> selectAllByEqualBetweenWithJoinLikesOrderByDescPaginated(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes, String orderByDescKey, int offset, int limit);

    public <T, V> List<T> selectAllByEqualWithJoinLikesOrderByDescPaginated(Class<T> clazz, String key, Object value, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes, String orderByDescKey, int offset, int limit);

    public <T, V> List<T> selectAllByEqualGtWithJoinLikesOrderByDescPaginated(Class<T> clazz, String key, Object value, String gtKey, Object gtValue, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes, String orderByDescKey, int offset, int limit);

    public <T, V> long selectCountByEqualBetweenWithJoinEqual(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, String joinKey, Object joinValue);

    public <T, V, X> long selectCountByEqualBetweenWithJoinJoinEqual(Class<T> clazz, String equalKey, Object equalValue, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz1, String joinClazz1Key, String joinClazz2Key, Class<X> joinClazz2, String join2Key, Object join2Value);

    public <T, V> long selectCountByEqualBetweenWithJoinLikes(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes);

    public <T, V> long selectCountByEqualWithJoinLikes(Class<T> clazz, String key, Object value, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes);

    public <T, V> long selectCountByEqualGtWithJoinLikes(Class<T> clazz, String key, Object value, String gtKey, Object gtValue, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes);

    public <T, V> V selectByEqualWithJoin(Class<T> clazz, String key, Object value, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz);

    public <T, U, V> List<U> selectAllByEqualWithJoinOrderByDesc(Class<T> clazz, String key, Object value, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Class<U> selector, String selectorKey, String orderByDescKey);

    // public <T, V> List<T> selectAllByEqualsWithJoin(Class<T> clazz, Map<String,

    // Object> clazzObjectParams, String clazzJoinKey, String joinClazzKey, Class<V>

    // joinClazz, Map<String, Object> joinClazzObjectParams);

    public <T> int deleteById(Class<T> clazz, int id);

    public <T> int deleteByEquals(Class<T> clazz, Map<String, Object> objectMap);

    public <T> int deleteByEqual(Class<T> clazz, String key, Object value);

    public <T> int updateById(Class<T> clazz, String key, Object value, int id);

    public <T> int updateByEquals(Class<T> clazz, String key, Object value, Map<String, Object> objectParams);

    public <U, T> List<U> selectAllDistinctByEqualsIns(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, Object> eqParams, Map<String, List<?>> inParams, String orderByKey, SortOrder sortOrder);

    public <T> List<T> selectAllByFoFoId(Class<T> clazz, String key, Object value, String orderByDescKey);

    <T> List<T> selectAllByEqualGtOrderByAsc(Class<T> clazz, String key, Object value, String gtKey, Object gtValue, String orderByDescKey);

    <T> List<T> selectAllByNullAndNotNull(Class<T> clazz, String nullKey, String notNullKey);

    <T> List<T> selectAllByEqualsOrderByAsc(Class<T> clazz, Map<String, Object> objectMap, String orderByAscKey);

    <X extends Comparable<? super X>, T> X selectMaxFieldValue(Class<T> class1, Class<X> class2, String field);

    <T, V> List<V> selectGroupBySum(Class<T> class1, Class<V> class2, Map<String, Object> equalsParam, String groupByField, String aggregateField);

    <T> List<T> selectAllByLikesOrderBy(Class<T> class1, int count, String sortKey, SortOrder sortOrder, Map<String, String>... andLikesMapList);

    <T> List<T> selectAllByLikes(Class<T> class1, String sortKey, SortOrder sortOrder, Map<String, String>... andLikesMapList);

    <T> List<T> selectAllByEqualLikesOrderBy(Class<T> class1, String key, Object value, String sortKey, SortOrder sortOrder, Map<String, String> andLikesMap);

    <T> List<T> selectAllByInEqualOrderByDescForUpdate(Class<T> clazz, String inKey, List<?> in, String key, Object value, String orderByDescKey);

    <T> List<T> selectAllByInsEqualsOrderByForUpdate(Class<T> clazz, Map<String, List<?>> listMap, Map<String, Object> objectMap, String orderByDescKey, SortOrder sortOrder);

    <T> T selectByIdForUpdate(Class<T> class1, int id);

    <T> List<T> selectAllByEqualsForUpdate(Class<T> clazz, Map<String, Object> objectMap);

    public <T> List<T> selectAllByEqualsOrOrderBy(Class<T> clazz, MultiValueMap<String, Object> equalMap, Map<String, Object> equalAndMap, String orderByDescKey, SortOrder sortOrder);

    <T> double selectAvgByEqualBetween(Class<T> clazz, String avgKey, Map<String, Object> objectParams, String betweenKey, Object betweenValue1, Object betweenValue2);

    public <T> Predicate prepareEqualPredicate(CriteriaBuilder builder, Root<T> root, Map<String, Object> objectParams);

    public <T> Predicate prepareNotInPredicate(CriteriaBuilder builder, Root<T> root, Map<String, List<?>> listParams);

    <T> Map<Object, Long> selectGroupByCount(Class<T> class1, Map<String, Object> equalsParams, String aggregateKey);

    <T> List<T> selectAllByOr(Class<T> class1, List<Map<String, Object>> equalsMapList);

    <T> List<SimpleEntry> selectLatestGroupBy(Class<T> class1, String groupBy, String keyColumn, List<Integer> assignedTo, LocalDateTime startDate, LocalDateTime endDate);

    /**

     * Selects valueColumn grouped by groupBy, where the row is determined by MAX of maxColumn.

     * Supports filtering via equalsMap (supports DateRangeModel for date range filters).

     *

     * @param class1 Entity class

     * @param groupBy Column to group by (e.g., "leadId")

     * @param valueColumn Column whose value to return (e.g., "schelduleTimestamp")

     * @param maxColumn Column to find MAX of to determine the row (e.g., "createdTimestamp")

     * @param equalsMap Filter conditions (supports DateRangeModel for date ranges)

     * @return List of SimpleEntry with groupBy value as key and valueColumn value as value

     */

    <T> List<SimpleEntry> selectValueByMaxOfAnotherColumn(Class<T> class1, String groupBy, String valueColumn, String maxColumn, Map<String, Object> equalsMap);

    <T> List<T> selectBetweenKeys(Class<T> tClass, String startKey, Object value, String endKey);

    <T> void deleteAll(Class<T> tClass);

    public List<Map<String, Object>> executeRawSqlAsListMap(String sql, List<Object> params);

}