Subversion Repositories SmartDukaan

package com.spice.profitmandi.dao.repository;

import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.stereotype.Repository;

@Repository
public interface GenericRepository {
        public <T> void persist(Object object);
        
        public <T> List<T> selectAll(Class<T> clazz);
        
        public <T> long selectCount(Class<T> clazz);
        public <T> long selectCountByEqualBetween(Class<T> clazz, String key, Object value, 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> T selectById(Class<T> clazz, int id);
        
        public <T> List<T> selectAllByIns(Class<T> clazz, Map<String, List<?>> listMap);
        public <U, T> List<U> selectAllByIns(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, List<?>> listMap);
        
        public <T> List<T> selectAllByIn(Class<T> clazz, String key, List<?> in);
        public <U, T> List<U> selectAllByIn(Class<T> clazz, Class<U> selector, String selectorKey, String inKey, List<?> in);
        
        public <T> List<T> selectAllByEquals(Class<T> clazz, Map<String, Object> objectMap);
        public <U, T> List<U> selectAllByEquals(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, Object> objectMap);
        
        public <T> List<T> selectAllByEqual(Class<T> clazz, String key, Object value);
        
        public <T> List<T> selectAllByEqualGt(Class<T> clazz, String key, Object value, String gtKey, Object gtValue);
        
        public <T> List<T> selectAllByEqualPaginated(Class<T> clazz, String key, Object value, int offset, int limit);
        
        
        
        public <U, T> List<U> selectAllByEqual(Class<T> clazz, Class<U> selector, String selectorKey, String key, Object value);
        
        public <T> List<T> selectAllByInsEquals(Class<T> clazz, Map<String, List<?>> listMap, Map<String, Object> objectMap);
        public <U, T> List<U> selectAllByInsEquals(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, List<?>> listMap, Map<String, Object> objectMap);
        
        public <T> List<T> selectAllByInEqual(Class<T> clazz, String inKey, List<?> in, String key, Object value);
        public <U, T> List<U> selectAllByInEqual(Class<T> clazz, Class<U> selector, String selectorKey, String inKey, List<?> in, String key, Object value);
        
        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 orderByKey);
        
        public <T> List<T> selectAllByEqualsNullNotNullGeLe(Class<T> clazz, Map<String, Object> objectMap, Set<String> nullParams, Set<String> notNullParams, Map<String, Object> geParams, Map<String, Object> leParams);
        //public <T> List<T> selectAllByInsEqualsNullNotNullGtGeLtLe(Class<T> clazz, Map<String, List<?>> listMap, Map<String, Object> objectMap, Set<String> nullParams, Set<String> notNullParams, Map<String, Object> gtParams, Map<String, Object> geParams, Map<String, Object> ltParams, Map<String, Object> leParams);
        
        public <T> List<T> selectAllByEqualBetween(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2);
        
        public <T> long selectCountByEqualsBetween(Class<T> clazz, Map<String, Object> objectParams, String betweenKey, Object betweenValue1, Object betweenValue2);
        
        public <T> List<T> selectAllByEqualBetweenPaginated(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, int offset, int limit);
        
        public <U, T> List<U> selectAllByParams(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, List<?>> listMap, Map<String, Object> objectMap, Set<String> nullParams, Set<String> notNullParams, Map<String, Object> gtParams, Map<String, Object> geParams, Map<String, Object> ltParams, Map<String, Object> leParams);
        
        public <T> T selectByEquals(Class<T> clazz, Map<String, Object> objectMap);
        
        public <T> List<T> selectAllByEqualsWithOrOrderByDescPaginated(Class<T> clazz, Map<String, Object> objectMap, String orderByKey, int offset, int limit);
        
        public <T> T selectByEqual(Class<T> clazz, String key, Object value);
        
        public <T> T selectByBetween(Class<T> clazz, String key, Object value1, Object value2);
        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);
        public <U, T> U selectByGeLe(Class<T> clazz, Class<U> selector, String selectorKey, String geKey, Object geValue, String leKey, Object leValue);
        
        //public <T> T selectByParams(Class<T> clazz, Map<String, Object> objectMap, Set<String> nullParams, Set<String> notNullParams, Map<String, Object> gtParams, Map<String, Object> geParams, Map<String, Object> ltParams, Map<String, Object> leParams);
        public <U, T> U selectByParams(Class<T> clazz, Class<U> selector, String selectorKey, Map<String, Object> objectMap, Set<String> nullParams, Set<String> notNullParams, Map<String, Object> gtParams, Map<String, Object> geParams, Map<String, Object> ltParams, Map<String, Object> leParams);
        
        public <T> List<T> selectAllByBetweenOrderByDesc(Class<T> clazz, String betweenKey, Object betweenValue1, Object betweenValue2, String orderByKey);
        
        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> selectAll(Class<T> clazz, Class<U> selector, String selectorKey);
        public <U, T> List<U> selectAllPaginated(Class<T> clazz, Class<U> selector, String selectorKey, int offset, int limit);
        
        public <T, V> List<T> selectAllByEqualBetweenWithJoinEqualPaginated(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, String joinKey, Object joinValue, int offset, int limit);
        
        public <T, V> V selectByEqualsWithJoinEqual(Class<T> clazz, Map<String, Object> objectParams, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, String joinKey, Object joinValue);
        
        public <T, V, X> List<T> selectAllByEqualBetweenWithJoinJoinEqualPaginated(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, int offset, int limit);
        
        
        public <T, V> List<T> selectAllByEqualBetweenWithJoinLikesPaginated(Class<T> clazz, String key, Object value, String betweenKey, Object betweenValue1, Object betweenValue2, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes, int offset, int limit);
        
        public <T, V> List<T> selectAllByEqualWithJoinLikesPaginated(Class<T> clazz, String key, Object value, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes, int offset, int limit);
        
        public <T, V> List<T> selectAllByEqualGtWithJoinLikesPaginated(Class<T> clazz, String key, Object value, String gtKey, Object gtValue, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Map<String, String> joinLikes, 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> selectAllByEqualWithJoin(Class<T> clazz, String key, Object value, String clazzJoinKey, String joinClazzKey, Class<V> joinClazz, Class<U> selector, String selectorKey);
        //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);
        
}