/******************************************************************************
 * Copyright (C) 2015 Shenzhen Penguin Network Technology Co., Ltd
 * All Rights Reserved.
 * 本软件为深圳市企鹅网络科技有限公司开发研制。未经本公司正式书面同意，其他任何个人、团体
 * 不得使用、复制、修改或发布本软件.
 *****************************************************************************/

package com.qxueyou.scc.base.service.impl;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import com.querydsl.jpa.impl.JPAQueryFactory;
import com.qxueyou.scc.base.dao.CommonDAO;
import com.qxueyou.scc.base.model.ITrace;
import com.qxueyou.scc.base.model.Pager;
import com.qxueyou.scc.base.model.Result;
import com.qxueyou.scc.base.service.ICommonService;
import com.qxueyou.scc.base.util.TraceUtils;
import com.qxueyou.scc.sys.model.SysDictionary;

@Service(value = "commonAppService")
/**
 * @author 夏德虎
 * @since JDK1.7
 * @history 2014-11-18 夏德虎 新建
 */
public class CommonAppService implements ICommonService {
	/**
	 * 获取事务管理器
	 */
    @PersistenceContext
    public EntityManager em;
    
    /**
     * 获取querydsl 查询工厂
     */
    public JPAQueryFactory queryFactory;
    
    private CommonDAO commonDAO;


    public CommonDAO getCommonDAO(){
        return commonDAO;
    }
    
    public JPAQueryFactory getQueryFactory() {
		return new JPAQueryFactory(em);
	}


	/**
     * 删除实体
     * @param trace
     */
	public void deleteTrace(ITrace trace) {
		trace.setDeleteFlag(true);
		TraceUtils.setUpdateTrace(trace);
		save(trace);
	}

    /**
     * 删除实体集合
     * @param traces
     */
	public <T extends ITrace> void  deleteTraces(List<T> traces) {
		for (ITrace trace : traces) {
			deleteTrace(trace);
		}
	}

    /**
     * 依赖注入
     *
     * @param commonDAO
     */
    @Autowired(required = false)
    public void setCommonDAO(@Qualifier("commonDao")
    CommonDAO commonDAO) {
        this.commonDAO = commonDAO;
    }

    /**
     * 读取对象
     * @param <T> 泛型
     * @param clz 实体类型
     * @param pk 实体主键
     * @return 查询结果
     */
    public <T> T read(Class<T> clz,Serializable pk){
        return this.commonDAO.read(clz, pk);
    }
    

    /**
     * 保存对象
     * @return 查询结果
     */
    public Result save(Object obj){
        this.commonDAO.saveOrUpdate(obj);
        return new Result(true);

    }
    
    /**
     * 刷新对象 手动提交
     * @return 查询结果
     */
    public void flush(){
    	getCommonDAO().getHibernateTemplate().flush();
    }
    
    /**
     * 清除缓存
     */
    public void clearCache(){
    	getCommonDAO().getHibernateTemplate().clear();
    }
    
    /**
     * 清除单个缓存
     */
    public void evict(Object obj){
    	getCommonDAO().getHibernateTemplate().evict(obj);
    }
    
    /**
     * 保存对象
     * @return 查询结果
     */
    public Result insert(Object obj){
        this.commonDAO.save(obj);
        return new Result(true);

    }
    
    /**
     * 保存对象
     * @return 查询结果
     */
    @SuppressWarnings("rawtypes")
	public Result saveOrUpdateAll(Collection collection){
        commonDAO.saveOrUpdateAll(collection);
        return new Result(true);

    }
    
    /**
     * 根据hql查询,并返回执行类型的列表结果
     * @param hql 查询语句
     * @param args 参数
     * @param cls 返回类型
     * @return
     */
    public <T> List<T> find(String hql,List<Object> args,Class<T> cls){
        return this.commonDAO.find(hql, args, cls);
    }
    
    /**
     * 根据hql查询,并返回执行类型的列表结果
     *
     * @param hql 查询语句
     * @param cls 返回类型
     * @return
     */
	public int findCount(String hql, List<Object> args) {
        return  this.commonDAO.findCount(hql, args);
    }
	
    
	/**
     * 保存或更新对象
     */
    public void deleteAll(@SuppressWarnings("rawtypes") Collection col) {
    	this.commonDAO.deleteAll(col);
    }
    
    /**
     * 根据hql查询,并返回执行类型的唯一结果
     * @param hql 查询语句
     * @param args 参数
     * @param cls 返回类型
     * @return
     */
    public <T> T findUnique(String hql,List<Object> args,Class<T> cls){
        return this.commonDAO.findUnique(hql, args, cls);
    }

    /**
     * 使用sql查询结果
     * @param sql
     * @param args
     * @return
     */
    @SuppressWarnings("rawtypes")
	public List findBySql(final String sql,final List<Object> args){
        return this.commonDAO.findBySql(sql, args);
    }
    
    /**
     * 使用sql查询结果
     * @param sql
     * @param args
     * @return
     */
    @SuppressWarnings("rawtypes")
	public List findByPageSql(final String sql,final List<Object> args, final Pager pager){
        return this.commonDAO.findByPageSql(sql, args, pager);
    }
    
    /**
     * 使用sql查询结果
     * @param sql
     * @param args
     * @return
     */
	public int findCountBySql(final String sql,final List<Object> args){
        return  this.commonDAO.findCountBySql(sql, args);
    }
    
    public Result bulkUpdate(String hql, Object args[]) {
    	return this.commonDAO.bulkUpdate(hql, args);
    }
    
    public Result executeProduce(String sql, Object args[]) {
    	return this.commonDAO.executeProduce(sql, args);
    }
    
    public int executeDelete(String sql, Object args[]) {
    	return this.commonDAO.executeSqlDelete(sql, args);
    }
    
    /**
     * hql只含单一参数
     *
     * @param hql 查询语句
     * @param args 参数数组
     * @param cls 返回类型
     * @return
     */
    public Result bulkUpdateInLoop(String hql, Object args[]) {
        return this.commonDAO.bulkUpdateInLoop(hql, args);
    }
    
    /**
     * 复杂hql
     * @param sql
     * @param map
     * @param cls
     * @return
     */
    public <T> List<T> findByComplexHql(final String hql, final Map<String, Object> map, Class<T> cls){
    	 return this.commonDAO.findByComplexHql(hql, map, cls);
    }
    
    /**
     * 复杂hql
     * @param sql
     * @param map
     * @param cls
     * @return
     */
    public <T> T findUniqueByHql(final String hql, final Map<String, Object> map){
    	 return commonDAO.findUniqueByHql(hql, map);
    }
    
    /**
     * 复杂hql
     * @param sql
     * @param map
     * @param cls
     * @return
     */
    public <T> List<T> findByComplexHql(final String hql, final Pager page, final Map<String, Object> map, Class<T> cls){
    	 return this.commonDAO.findByComplexHql(hql, page, map, cls);
    }
    
    /**
     * 返回个数 复杂hql
     *
     * @param hql 查询语句
     * @param cls 返回类型
     * @return
     */
	public int findCountByComplexHql(final String hql, final Map<String, Object> map) {
        return  this.commonDAO.findCountByComplexHql(hql, map);
    }
	
	 /**
     * 返回个数 复杂sql
     *
     * @param hql 查询语句
     * @param cls 返回类型
     * @return
     */
	public int findCountByComplexSql(final String hql, final Map<String, Object> map) {
        return  this.commonDAO.findCountByComplexSql(hql, map);
    }
	
    /**
     * 复杂sql
     * @param sql
     * @param map
     * @param cls
     * @return
     */
    public <T> List<T> findByComplexSql(final String sql, final Map<String, Object> map, Class<T> cls){
    	 return this.commonDAO.findByComplexSql(sql, map, cls);
    }
    
    /**
     * 复杂hql
     * @param sql
     * @param map
     * @param cls
     * @return
     */
    public <T> List<T> findByComplexSql(final String sql, final Pager page, final Map<String, Object> map, Class<T> cls){
    	 return this.commonDAO.findByComplexSql(sql, page, map, cls);
    }
    
    /**
     * 根据hql查询,并返回执行类型的列表结果，列表数据为Map
     * @param hql
     * @param map
     * @return
     */
    public List<Map<String,Object>> findListWithMapByHql(final String hql, final Map<String, Object> map){
    	return this.commonDAO.findListWithMapByHql(hql, map);
    }
    
    /**
     * 根据hql查询,并返回执行类型的列表结果，列表数据为Map
     * @param hql
     * @param args
     * @return
     */
    public List<Map<String,Object>> findListWithMapByHql(final String hql, final Map<String, Object> args,final Pager page){
    	return this.commonDAO.findListWithMapByHql(hql, args,page);
    }
    
    /**
     * 分页查询
     * @param hql
     * @param page
     * @param args
     * @param cls
     * @return
     */
    public <T> List<T> findList(final String hql, final Pager page, final List<Object> args,Class<T> cls){
    	return this.commonDAO.findList(hql, page, args, cls);
    }
    
    /**
     * 查询
     * @param hql
     * @param args
     * @return
     */
	public List<Object[]> findwithRawResult(String hql, List<Object> args) {
        return this.commonDAO.findwithRawResult(hql, args);
    }
	

	/**
	 * 根据配置key查询value值 
	 * @param key
	 * @return
	 */
	public String queryConfigValue(String key){
		return this.commonDAO.queryConfigValue(key);
	}
	
	/**
	 * 根据字典类型查询字典内容的list
	 * @param dicType
	 * @return
	 */
	public List<SysDictionary> queryDictConfigMap(String dicType){
		return this.commonDAO.queryDictConfigMap(dicType);
	}
}