VentureManageService 类

最新推荐文章于 2019-08-09 10:35:30 发布
最新推荐文章于 2019-08-09 10:35:30 发布
阅读量309 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rucheng_hjp/article/details/48106107
版权
package com.starise.project.service.impl.fxgl;


import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;


import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import com.starise.project.dao.IVentureManageDao;
import com.starise.project.service.common.ICommonService;
import com.starise.project.service.fxgl.IVentureManageService;
import com.starise.project.util.Constants;
import com.starise.project.util.Toolkits;
import com.starise.project.util.Constants.OperateModual;
import com.starise.project.util.Constants.OperateType;


@Service("ventureManageService")
public class VentureManageService implements IVentureManageService{
private static final Logger logger= Logger.getLogger(VentureManageService.class);

@Autowired
private IVentureManageDao ventureManageDao = null;
@Autowired
private ICommonService commonServiceImpl = null;



/************************************检查内容信息维护模块 *****************************************/

@Override
public Map insertCheckContent(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加检查内容信息请求-------->:"+paramMap);
String id=UUID.randomUUID().toString().replace("-", "");
paramMap.put("id",id);
ventureManageDao.insertCheckContent(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加检查内容信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加检查内容信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map updateCheckContent(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新检查内容信息请求-------->:"+paramMap);
ventureManageDao.updateCheckContent(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新检查内容信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 更新检查内容信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map queryCheckContent(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据条件查询检查内容信息  请求-------->:"+paramMap);
String nrTotal=ventureManageDao.queryCheckContentTotal(paramMap);
if(null != nrTotal && !"0".equals(nrTotal)){
List allCheckList = ventureManageDao.queryCheckContent(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",allCheckList,nrTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("根据条件查询检查内容信息   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   根据条件查询检查内容信息   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map queryCheckContentById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据ID查询检查内容详细信息  请求-------->:"+paramMap);
List checkInfoList = ventureManageDao.queryCheckContentById(paramMap);
if(null != checkInfoList && checkInfoList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",checkInfoList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("根据ID查询检查内容详细信息   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   根据ID查询检查内容详细信息   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map deleteCheckContent(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("删除检查内容信息请求-------->:"+paramMap);
ventureManageDao.deleteCheckContent(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("删除检查内容信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   删除检查内容信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}


/************************************营业(前/后)/录像检查信息维护模块 *******************************/

@Override
public Map queryAllSalesCheck(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询所有营业检查列表（前/后）请求-------->:"+paramMap);
String yyTotal=ventureManageDao.queryAllSalesCheckTotal(paramMap);
if(null != yyTotal && !"0".equals(yyTotal)){
List allCheckList = ventureManageDao.queryAllSalesCheck(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",allCheckList,yyTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询所有营业检查列表（前/后）返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 查询所有营业检查列表（前/后）  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryAllVideoCheck(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询所有录像检查列表  请求-------->:"+paramMap);
String lxTotal=ventureManageDao.queryAllVideoCheckTotal(paramMap);
if(null != lxTotal && !"0".equals(lxTotal)){
List allCheckList = ventureManageDao.queryAllVideoCheck(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",allCheckList,lxTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询所有录像检查列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询所有录像检查列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map querySalesCheckDetail(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据ID和类型查询营业检查明细请求-------->:"+paramMap);
List allCheckList = ventureManageDao.querySalesCheckDetail(paramMap);
if(null != allCheckList && allCheckList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",allCheckList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("根据ID和类型查询营业检查明细返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  根据ID和类型查询营业检查明细   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}

@Override
public Map queryVideoCheckDetail(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据ID和类型查询录像检查明细请求-------->:"+paramMap);
List allCheckList = ventureManageDao.queryVideoCheckDetail(paramMap);
if(null != allCheckList && allCheckList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",allCheckList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("根据ID和类型查询录像检查明细返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  根据ID和类型查询录像检查明细   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}

@Override
public Map deleteSalesCheckById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据id删除营业检查请求-------->:"+paramMap);
//删除营业检查信息
ventureManageDao.deleteSalesCheckById(paramMap);
//根据检查id删除检查明细信息
ventureManageDao.deleteCheckDetailById(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("根据id删除营业检查返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJC.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJC.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 根据id删除营业检查  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}


@Override
public Map deleteVideoCheckById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据id删除录像检查请求-------->:"+paramMap);
//删除录像检查信息
ventureManageDao.deleteVideoCheckById(paramMap);
//根据检查id删除检查明细信息
ventureManageDao.deleteCheckDetailById(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("根据id删除录像检查返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJC.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJC.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 根据id删除录像检查  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}

@Override
public Map insertSalesCheck(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加营业检查信息请求-------->:"+paramMap);
//营业检查ID
String id=UUID.randomUUID().toString().replace("-", "");
paramMap.put("id",id);
paramMap.put("yyjcid",id);
ventureManageDao.insertSalesCheck(paramMap);
//添加营业检查明细
List yyjcmxList=(List)paramMap.get("yyjcmx");
if(null != yyjcmxList && yyjcmxList.size() > 0){
Map yyjcmxMap=null;
String yyjcid=String.valueOf(paramMap.get("yyjcid"));
for(int i=0;i<yyjcmxList.size();i++){
yyjcmxMap=(Map) yyjcmxList.get(i);
yyjcmxMap.put("id", UUID.randomUUID().toString().replace("-", ""));
yyjcmxMap.put("jcid", yyjcid);
ventureManageDao.insertCheckDetail(yyjcmxMap);
}
}
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加营业检查信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJC.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJC.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加营业检查信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map insertVideoCheck(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加录像检查信息请求-------->:"+paramMap);

//String countNum = ventureManageDao.queryCountNumber(paramMap);
//录像检查ID
String id=UUID.randomUUID().toString().replace("-", "");
paramMap.put("id",id);
paramMap.put("lxjcid",id);
//检查次数
//paramMap.put("dtjccs", Integer.valueOf(countNum) + 1);
ventureManageDao.insertVideoCheck(paramMap);
//添加录像检查明细
List lxjcmxList=(List)paramMap.get("lxjcmx");
if(null != lxjcmxList && lxjcmxList.size() > 0){
Map lxjcmxMap=null;
String lxjcid=String.valueOf(paramMap.get("lxjcid"));
for(int i=0;i<lxjcmxList.size();i++){
lxjcmxMap=(Map) lxjcmxList.get(i);
lxjcmxMap.put("id", UUID.randomUUID().toString().replace("-", ""));
lxjcmxMap.put("jcid", lxjcid);
ventureManageDao.insertCheckDetail(lxjcmxMap);
}
}
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加录像检查信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJC.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJC.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加录像检查信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map queryCountNumber(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据检查时间/机构查询录像检查次数信息请求-------->:"+paramMap);
String countNum = ventureManageDao.queryCountNumber(paramMap);
//检查次数+1
if(null != countNum && !"0".equals(countNum)){
returnMap=Toolkits.buildSuccessMap("查询成功！",countNum);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("根据检查时间/机构查询录像检查次数信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 根据检查时间/机构查询录像检查次数信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map insertCheckDetail(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加营业/录像检查明细信息请求-------->:"+paramMap);
ventureManageDao.insertCheckDetail(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加营业/录像检查明细信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJC.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJC.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加营业/录像检查明细信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map updateSalesCheckMessage(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新营业检查信息请求-------->:"+paramMap);
//更新营业检查主表信息
ventureManageDao.updateSalesCheckMessage(paramMap);
//更新营业检查信息——删除原有营业检查明细信息
ventureManageDao.deleteCheckDetailById(paramMap);
//重新插入营业检查明细信息
List yyjcmxList=(List)paramMap.get("yyjcmx");
if(null != yyjcmxList && yyjcmxList.size() > 0){
Map yyjcmxMap=null;
for(int i=0;i<yyjcmxList.size();i++){
yyjcmxMap=(Map) yyjcmxList.get(i);
yyjcmxMap.put("id", UUID.randomUUID().toString().replace("-", ""));
yyjcmxMap.put("jcid", paramMap.get("jcid"));
ventureManageDao.insertCheckDetail(yyjcmxMap);
}
}
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新营业检查信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJC.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJC.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 更新营业检查信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map updateVideoCheckMessage(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新录像检查信息  请求-------->:"+paramMap);
//更新录像检查主表信息
ventureManageDao.updateVideoCheckMessage(paramMap);
//更新录像检查信息——删除原有录像检查明细信息
ventureManageDao.deleteCheckDetailById(paramMap);
//重新插入录像检查明细信息
List lxjcmxList=(List)paramMap.get("lxjcmx");
if(null != lxjcmxList && lxjcmxList.size() > 0){
Map lxjcmxMap=null;
for(int i=0;i<lxjcmxList.size();i++){
lxjcmxMap=(Map) lxjcmxList.get(i);
lxjcmxMap.put("id", UUID.randomUUID().toString().replace("-", ""));
lxjcmxMap.put("jcid", paramMap.get("jcid"));
ventureManageDao.insertCheckDetail(lxjcmxMap);
}
}
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新录像检查信息  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJC.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJC.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 更新录像检查信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map salesContrast(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;


try {
logger.info("查询营业(前/后)检查对比  请求-------->:"+paramMap);
String jcid=String.valueOf(paramMap.get("jcid"));
String[] jcids=jcid.split(",");
paramMap.put("jcidList", jcids);
List conList = ventureManageDao.salesContrast(paramMap);
if(null != conList && conList.size() > 0){
Map map=(Map)conList.get(0);
List salesList = ventureManageDao.contrastSubtabulation(paramMap);
map.put("sales", salesList);
returnMap=Toolkits.buildSuccessMap("查询成功！",map);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询营业(前/后)检查对比  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询营业(前/后)检查对比  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map videoContrast(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询录像检查对比  请求-------->:"+paramMap);
String jcid=String.valueOf(paramMap.get("jcid"));
String[] jcids=jcid.split(",");
paramMap.put("jcidList", jcids);
List conList = ventureManageDao.videoContrast(paramMap);
if(null != conList && conList.size() > 0){
Map map=(Map)conList.get(0);
List videoList = ventureManageDao.contrastSubtabulation(paramMap);
map.put("video", videoList);
returnMap=Toolkits.buildSuccessMap("查询成功！",map);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询录像检查对比  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  录像检查对比  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}



@Override
public Map contrastSubtabulation(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;


try {
logger.info("查询营业(前/后)、录像检查对比  请求-------->:"+paramMap);
String jcid=String.valueOf(paramMap.get("jcid"));
String[] jcids=jcid.split(",");
paramMap.put("jcidList", jcids);
List conList = ventureManageDao.contrastSubtabulation(paramMap);

String temp = "";
List allList = new ArrayList();
if(null != conList && conList.size() > 0){
for(int i=0; i<conList.size(); i++){
Map reMap = (Map) conList.get(i);
if(i==0){
temp = (String) reMap.get("jcid");
Map rsMap = new HashMap();
List one = new ArrayList();
rsMap.put("jcid", temp);
one.add(reMap);
rsMap.put("jcList", one);
allList.add(rsMap);
}else{
temp = (String) reMap.get("jcid");

Boolean res = false;
for(int j=0;j<allList.size();j++){
Map aMap = (Map)allList.get(j);
if(temp.equals(aMap.get("jcid"))){
List jcList = (List) aMap.get("jcList");
jcList.add(reMap);
res = true;
break;
}
}
if(res == false){
Map rsMap = new HashMap();
List other = new ArrayList();
rsMap.put("jcid", temp);
other.add(reMap);
rsMap.put("jcList", other);
allList.add(rsMap);
}

}
}
returnMap=Toolkits.buildSuccessMap("查询成功！",allList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询营业(前/后)、录像检查对比  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJC.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询营业(前/后)、录像检查对比  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}



/************************************联防报警测试及防区信息维护模块 ******************************/

@Override
public Map insertDefenseAlarm(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加联防报警测试信息请求-------->:"+paramMap);

//联防报警测试ID
String id=UUID.randomUUID().toString().replace("-", "");
paramMap.put("id",id);
paramMap.put("lfbjcsid", id);
ventureManageDao.insertDefenseAlarm(paramMap);
//添加防区关联
List fqglmxList=(List)paramMap.get("fqglmx");
if(null != fqglmxList && fqglmxList.size() > 0){
Map fqglmxMap=null;
String lfbjcsid=String.valueOf(paramMap.get("lfbjcsid"));
for(int i=0;i<fqglmxList.size();i++){
fqglmxMap=(Map) fqglmxList.get(i);
fqglmxMap.put("id", UUID.randomUUID().toString().replace("-", ""));
fqglmxMap.put("lfbjcsid", lfbjcsid);
ventureManageDao.insertJointDefenceArea(fqglmxMap);
}
}
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加联防报警测试信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZLFBJCS.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZLFBJCS.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  添加联防报警测试信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map insertJointDefenceArea(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加联防报警测试_防区关联信息请求-------->:"+paramMap);
ventureManageDao.insertJointDefenceArea(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加联防报警测试_防区关联信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZLFBJCS.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZLFBJCS.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加联防报警测试_防区关联信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryDefenseAlarm(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询联防报警测试列表  请求-------->:"+paramMap);
String lfbjTotal=ventureManageDao.queryDefenseAlarmTotal(paramMap);
if(null != lfbjTotal && !"0".equals(lfbjTotal)){
List allList = ventureManageDao.queryDefenseAlarm(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",allList,lfbjTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询联防报警测试列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXLFBJCS.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXLFBJCS.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询联防报警测试列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryJointDefenceArea(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询联防报警测试_防区关联请求-------->:"+paramMap);
List allList = ventureManageDao.queryJointDefenceArea(paramMap);
if(null != allList && allList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",allList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询联防报警测试_防区关联返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXLFBJCS.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXLFBJCS.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询联防报警测试_防区关联   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}

@Override
public Map deleteDefenseAlarmById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据id删除联防报警测试请求-------->:"+paramMap);
//删除联防报警测试信息
ventureManageDao.deleteDefenseAlarmById(paramMap);
//根据联防报警测试id删除防区关联信息
ventureManageDao.deleteJointDefenceAreaById(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("根据id删除联防报警测试返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCLFBJCS.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCLFBJCS.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   根据id删除联防报警测试  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}

@Override
public Map updateDefenseAlarm(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新联防报警测试信息请求-------->:"+paramMap);
//更新联防报警测试信息
ventureManageDao.updateDefenseAlarm(paramMap);
//更新联防报警测试信息——删除原有联防报警测试_防区关联
ventureManageDao.deleteJointDefenceAreaById(paramMap);
//重新插入联防报警测试_防区关联
List fqglmxList=(List)paramMap.get("fqglmx");
if(null != fqglmxList && fqglmxList.size() > 0){
Map fqglmxMap=null;
for(int i=0;i<fqglmxList.size();i++){
fqglmxMap=(Map) fqglmxList.get(i);
fqglmxMap.put("id", UUID.randomUUID().toString().replace("-", ""));
fqglmxMap.put("lfbjcsid", paramMap.get("lfbjcsid"));
ventureManageDao.insertJointDefenceArea(fqglmxMap);
}
}
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新联防报警测试信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGLFBJCS.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGLFBJCS.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  更新联防报警测试信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}





/************************************培训教育信息维护模块 *****************************************/

@Override
public Map insertTrainingProject(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加培训项目信息请求-------->:"+paramMap);
// String id=UUID.randomUUID().toString().replace("-", "");
// paramMap.put("id",id);
ventureManageDao.insertTrainingProject(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加培训项目信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZPXXM.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZPXXM.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加培训项目信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryTrainingProject(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询培训项目信息列表  请求-------->:"+paramMap);
String pxxmTotal=ventureManageDao.queryTrainingProjectTotal(paramMap);
if(null != pxxmTotal && !"0".equals(pxxmTotal)){
List allList = ventureManageDao.queryTrainingProject(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",allList,pxxmTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询培训项目信息列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询培训项目信息列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map checkVenturePxBmOrMc(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("培训项目 -验证 编码请求-------->:"+paramMap);
List checkList=ventureManageDao.checkVenturePxBmOrMc(paramMap);
if(null != checkList && checkList.size() > 0){
returnMap=Toolkits.buildSuccessMap("操作成功！",checkList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据！");
}
logger.info("培训项目 -验证 编码返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);

} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   培训项目 -验证 编码  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map queryInitTraining(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询培训项目用于下拉框请求-------->:"+paramMap);
List initList=ventureManageDao.queryInitTraining(paramMap);
if(null != initList && initList.size() > 0){
returnMap=Toolkits.buildSuccessMap("操作成功！",initList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据！");
}
logger.info("查询培训项目用于下拉框返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);

} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   查询培训项目用于下拉框  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryTrainingProjectById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据ID查询培训项目详细信息  请求-------->:"+paramMap);
List tpInfoList = ventureManageDao.queryTrainingProjectById(paramMap);
if(null != tpInfoList && tpInfoList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",tpInfoList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("根据ID查询培训项目详细信息   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXXM.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   根据ID查询培训项目详细信息   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map updateTrainingProject(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新培训项目信息请求-------->:"+paramMap);
ventureManageDao.updateTrainingProject(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新培训项目信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGPXXM.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGPXXM.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 更新培训项目信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map deleteTrainingProjectById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("删除培训项目信息请求-------->:"+paramMap);
ventureManageDao.deleteTrainingProjectById(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("删除培训项目信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCPXXM.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCPXXM.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   删除培训项目信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map insertTrainingEducation(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加培训教育信息请求-------->:"+paramMap);
String id=UUID.randomUUID().toString().replace("-", "");
paramMap.put("id",id);
ventureManageDao.insertTrainingEducation(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加培训教育信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZPXJY.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZPXJY.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加培训教育信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryTrainingEducation(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询培训教育信息列表  请求-------->:"+paramMap);
String pxjyTotal=ventureManageDao.queryTrainingEducationTotal(paramMap);
if(null != pxjyTotal && !"0".equals(pxjyTotal)){
List allList = ventureManageDao.queryTrainingEducation(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",allList,pxjyTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询培训教育信息列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXJY.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXJY.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询培训教育信息列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryDrillProjectMultiCheck(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询演练项目用于多选  请求-------->:"+paramMap);
List checkList = ventureManageDao.queryDrillProjectMultiCheck(paramMap);
if(null != checkList && checkList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",checkList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询演练项目用于多选  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询演练项目用于多选  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map queryTrainingEducationById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("根据ID查询培训教育详细信息  请求-------->:"+paramMap);
List teInfoList = ventureManageDao.queryTrainingEducationById(paramMap);
if(null != teInfoList && teInfoList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",teInfoList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("根据ID查询培训教育详细信息   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXJY.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXPXJY.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   根据ID查询培训教育详细信息   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map deleteTrainingEducationById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("删除培训教育信息请求-------->:"+paramMap);
ventureManageDao.deleteTrainingEducationById(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("删除培训教育信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCPXJY.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCPXJY.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   删除培训教育信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map updateTrainingEducation(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新培训教育信息请求-------->:"+paramMap);
ventureManageDao.updateTrainingEducation(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新培训教育信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGPXJY.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGPXJY.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 更新培训教育信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}




/*******************************************检查大类/检查小类管理********************************************/

@Override
public Map insertExaminationCategories(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加检查大类信息请求-------->:"+paramMap);
//添加检查大类
ventureManageDao.insertExaminationCategories(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加检查大类信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJCDL.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJCDL.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 添加检查大类信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map deleteExaminationCategoriesById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("删除检查大类信息请求-------->:"+paramMap);
//删除检查大类信息
ventureManageDao.deleteExaminationCategoriesById(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("删除检查大类信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJCDL.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJCDL.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 删除检查大类信息信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}

@Override
public Map updateExaminationCategories(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新检查大类信息请求-------->:"+paramMap);
//更新大类信息
ventureManageDao.updateExaminationCategories(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新检查大类信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJCDL.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJCDL.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   更新检查大类信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map queryExaminationCategories(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询检查大类列表  请求-------->:"+paramMap);
String jcdlTotal=ventureManageDao.queryExaminationCategoriesTotal(paramMap);
if(null != jcdlTotal && !"0".equals(jcdlTotal)){
List jcdlList = ventureManageDao.queryExaminationCategories(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",jcdlList,jcdlTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询检查大类列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询检查大类列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map insertCheckTheSmallClass(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("添加检查小类信息请求-------->:"+paramMap);
ventureManageDao.insertCheckTheSmallClass(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("添加检查小类信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJCXL.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XZJCXL.toString(), OperateType.OPERATE_TYPE_ADD.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   添加检查小类信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map deleteCheckTheSmallClassById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("删除检查小类信息请求-------->:"+paramMap);
//删除检查小类信息
ventureManageDao.deleteCheckTheSmallClassById(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");

logger.info("删除检查小类信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJCXL.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap = Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_SCJCXL.toString(), OperateType.OPERATE_TYPE_DELETE.toString(), Constants.OPERATE_FAILURE);
logger.error("service层 删除检查小类信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);
return returnMap;
}

@Override
public Map updateCheckTheSmallClass(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("更新检查小类信息请求-------->:"+paramMap);
//更新小类信息
ventureManageDao.updateCheckTheSmallClass(paramMap);
returnMap=Toolkits.buildSuccessMap("操作成功！");
logger.info("更新检查小类信息返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJCXL.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_XGJCXL.toString(), OperateType.OPERATE_TYPE_MODIFY.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  更新检查小类信息  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryCheckTheSmallClass(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询检查小类列表  请求-------->:"+paramMap);
String jcxlTotal=ventureManageDao.queryCheckTheSmallClassTotal(paramMap);
if(null != jcxlTotal && !"0".equals(jcxlTotal)){
List jcxlList = ventureManageDao.queryCheckTheSmallClass(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",jcxlList,jcxlTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询检查大类列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCXL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCXL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询检查小类列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

@Override
public Map queryExaminationCategoriesById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询检查大类详细信息  请求-------->:"+paramMap);
List jcdlList = ventureManageDao.queryExaminationCategoriesById(paramMap);
if(null != jcdlList && jcdlList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",jcdlList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询检查大类详细信息   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   查询检查大类详细信息   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryCheckTheSmallClassById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询检查小类详细信息  请求-------->:"+paramMap);
List jcxlList = ventureManageDao.queryCheckTheSmallClassById(paramMap);
if(null != jcxlList && jcxlList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",jcxlList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询检查小类详细信息   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCXL.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCXL.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   查询检查小类详细信息   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryInitExamination(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询检查大类用于下拉框请求-------->:"+paramMap);
List initList=ventureManageDao.queryInitExamination(paramMap);
if(null != initList && initList.size() > 0){
returnMap=Toolkits.buildSuccessMap("操作成功！",initList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据！");
}
logger.info("查询检查大类用于下拉框返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);

} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询检查大类用于下拉框  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


public Map checkDlBmOrMc(Map paramMap) throws Exception{
Map returnMap=null;
Map logMap=null;

try {
logger.info("校验检查大类  编码请求-------->:"+paramMap);
List dlbmList=ventureManageDao.checkDlBmOrMc(paramMap);
if(null != dlbmList && dlbmList.size() > 0){
returnMap=Toolkits.buildSuccessMap("操作成功！",dlbmList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据！");
}
logger.info("校验检查大类  编码返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);

} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCDL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  校验检查大类  编码  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

public Map checkXlBmOrMc(Map paramMap) throws Exception{
Map returnMap=null;
Map logMap=null;

try {
logger.info("校验检查小类  编码请求-------->:"+paramMap);
List xlbmList=ventureManageDao.checkXlBmOrMc(paramMap);
if(null != xlbmList && xlbmList.size() > 0){
returnMap=Toolkits.buildSuccessMap("操作成功！",xlbmList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据！");
}
logger.info("校验检查小类  编码返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCXL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);

} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCXL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  校验检查小类  编码  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


/************************************检查监督信息维护模块 *****************************************/

@Override
public Map queryInspectionSupervision(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询检查监督列表  请求-------->:"+paramMap);
String jcjdTotal=ventureManageDao.queryInspectionSupervisionTotal(paramMap);
if(null != jcjdTotal && !"0".equals(jcjdTotal)){
List jcjdList = ventureManageDao.queryInspectionSupervision(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",jcjdList,jcjdTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询检查监督列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCJD.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCJD.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询检查监督列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


@Override
public Map queryInspectionSupervisionById(Map paramMap) throws Exception {
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询检查监督详细信息  请求-------->:"+paramMap);
List jcjdList = ventureManageDao.queryInspectionSupervisionById(paramMap);
if(null != jcjdList && jcjdList.size() > 0){
Map map=(Map)jcjdList.get(0);
List wttzList=ventureManageDao.queryInspectionSupervisionWttz(paramMap);
map.put("wttz", wttzList);
List qzzkList=ventureManageDao.queryInspectionSupervisionQzzk(paramMap);
map.put("qzzk", qzzkList);
returnMap=Toolkits.buildSuccessMap("查询成功！",map);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询检查监督详细信息   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCJD.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_CXJCJD.toString(), OperateType.OPERATE_TYPE_QUERY_MX.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   查询检查小类详细信息   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

public Map queryInspectionResult(Map paramMap) throws Exception{
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询枪支信息用于检查结果  请求-------->:"+paramMap);
List resultList = ventureManageDao.queryInspectionResult(paramMap);
if(null != resultList && resultList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",resultList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询枪支信息用于检查结果   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   查询枪支信息用于检查结果   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

public Map queryProblemOfAttribute(Map paramMap) throws Exception{
Map returnMap=null;
Map logMap=null;

try {
logger.info("查询业务字典用于问题属性  请求-------->:"+paramMap);
List problemList = ventureManageDao.queryProblemOfAttribute(paramMap);
if(null != problemList && problemList.size() > 0){
returnMap=Toolkits.buildSuccessMap("查询成功！",problemList);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询业务字典用于问题属性   返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层   查询业务字典用于问题属性   异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}

/************************************统计：安检日志查询信息维护模块  *****************************************/

/**
* ffbs=0:营业前检查,
* ffbs=1:营业后检查,
* ffbs=2:录像检查,
* ffbs=3:联防报警测试,
* ffbs=4:培训教育
*/
@Override
public Map queryAjrzCount(Map paramMap) throws Exception{

Map returnMap=null;
Map logMap=null;

try {
logger.info("查询统计安检日志列表  请求-------->:"+paramMap);
String countAjrzTotal=ventureManageDao.queryAjrzCountTotal(paramMap);
if(null != countAjrzTotal && !"0".equals(countAjrzTotal)){
List countAjrzList = ventureManageDao.queryAjrzCount(paramMap);
returnMap=Toolkits.buildSuccessMap("查询成功！",countAjrzList,countAjrzTotal);
}else{
returnMap=Toolkits.buildNotFindMap("未找到数据");
}
logger.info("查询统计安检日志列表  返回-------->:"+returnMap);

//操作日志参数
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_SUCCESS);
} catch (Exception e) {
returnMap=Toolkits.buildFailureMap("系统异常，操作失败，请联系管理员！");
logMap=Toolkits.buildOperateParamMap(paramMap, OperateModual.OPERATE_MODUAL_FXGL.toString(), OperateType.OPERATE_TYPE_QUERY_LIST.toString(), Constants.OPERATE_FAILURE);
logger.error("service层  查询统计安检日志列表  异常", e);
e.printStackTrace();
}
//保存操作日志
commonServiceImpl.addOperationLog(logMap);

return returnMap;
}


}
rucheng_hjp
关注
精通Spark集群搭建与测试
rucheng_hjp的专栏
06-14 245
精通Spark集群搭建与测试
rucheng_hjp_tables
rucheng_hjp的专栏
03-14 222
/*create table tabA (a1 number, a2 varchar2(100));   create table tabB (b1 number, a1 number, b2 varchar2(100));   create table tabC (c1 number, c2 varchar2(100));*/   alter table tabA ad
js 利用Math.random生成随机整数
qq_34621658的博客
08-09 3106
Math.random() 方法能够生成0~1之间的小数，可能会返回0但永远也不会是1。 在实际开发需求中，需要生成0到某个数之间的随机整数： Math.floor(Math.random()*10) 结合Math.floor()向下取整，能给我们随机生成0-9之间的整数。 但是请注意，上面只能生成0到某个数之间的随机数，但我们可以通过下面这个公式得到任何min和max之间随机数： 公式...
rucheng_hjp,如何获取iframe内容
rucheng_hjp的专栏
03-22 277
demo主页面             window.onload = function(){       var ids = "";     var tds = document.getElementById('iframeId').contentWindow.document.getElementsByClassName('td1');     for (var i = 0; i
stata软件安装包（stata18）（stata软件安装包下载与安装）
11-07
软件主体：stata软件安装包。版本：stata18。价格：免费。安装教程：请阅读本人相对应的安装教程文章。描述：安装教程保姆级别仔细，直接按步骤来就行了。本人申明：本安装包需要的人可以免费获取，不用于商业买卖，只用于学术研究。（如果可以帮到大家就给个关注吧）
基于Java的电力设备管理系统的开发与设计
11-07
内容概要：本文介绍了一个基于Java技术开发的电力设备管理系统的详细设计与实现过程。系统涵盖了电力设备、站点管理、技术资料图纸管理、建筑管理、审批流转等多个功能模块，通过高效的信息化手段，提高了电力设备的管理水平，降低了传统管理带来的冗余劳动，提升了工作效率。系统采用J2EE三层架构模式，使用SSH技术框架，前端使用JSP、CSS和JavaScript技术，数据库使用MySQL，实现了高内聚低耦合的系统架构。 适合人群：从事电力设备管理的IT从业人员，尤其是有一定Java开发基础的研发人员。 使用场景及目标：适用于需要对电力设备进行全面管理的企业，旨在提升电力设备管理的自动化水平和信息共享能力，从而减少人力投入，提高管理水平和安全性。 其他说明：本文提供了系统的总体架构、各功能模块的具体设计和实现细节，还讨论了系统测试的方法和测试用例，确保系统功能的完整性和可靠性。
【超强组合】基于VMD-蝠鲼觅食优化算法MRFO-Transformer-LSTM的光伏预测算研究Matlab实现.rar
11-07
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
【超强组合】基于VMD-鲸鱼优化算法WOA-Transformer-LSTM的光伏预测算研究Matlab实现.rar
11-07
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 替换数据可以直接使用，注释清楚，适合新手
栅格系统Grid布局.docx
11-07
栅格系统Grid布局.docx
【C语音期末/课程设计】通讯录管理系统(DevC项目)
11-07
题目描述： 建立一通讯录，输入姓名、电话号码、住址等信息，然后对通信簿进行显示、查找、添加、修改及删除。 功能要求： (1) 通讯录的每一条信息包括姓名、单位、移动手机、分类（如同事、朋友、同学、家人等）、EMAIL、QQ等。 (2) 输入功能：可以一次完成若干条信息的输入。 (3) 显示功能：完成全部通讯录信息的显示。 (4) 排序功能：按照一定的排序顺序显示通讯录信息。排序顺序有多种，如按姓名排序、按年龄排序、按所在城市排序、按所在单位排序等，具体使用的排序顺序由设计者确定。 (5) 查找功能：可以按姓名等多种方式查找通讯信息。 (6) 插入、删除（根据姓名）、修改（根据姓名）功能：完成通讯录信息的多种更新。 扩展功能： (1) 提供一些统计功能。例如可以按照分类进行统计。 (2) 通信录信息从文件读入。 (3) 将通讯录信息保存到文件中
02真题与答案 （二级）青少年软件编程（图形化）等级考试试卷.zip
11-07
2021-2024年共15套，二级编程等级考试真题与答案，明确目标，检验成果，熟悉考试，提升应试能力
JAVA音像店租赁管理系统的设计与实现(源代码+论文).zip
11-07
音像店租赁管理系统的设计与实现 摘 要 随着信息技术在管理上的广泛应用，管理信息系统（MIS）的实施在技术上已经逐步成熟。企业要生存、要发展、要高效率地把企业活动有效组织起来，就必须加强对企业内部各种资源（人、财、物）的有效管理，建立与自身特点相适应的管理信息系统。 本音像店管理租赁管理系统，设计并且完成了一个小型的音像店管理信息系统，使得经营者以及普通用户能对影碟的历史记录等进行操作。 本音像店租赁管理系统是一个典型的管理信息系统，在J2EE架构的基础下实现模块化，使用Struts和Hibernate技术实现并完成。在该系统的设计和实现过程中，采用了一些新技术，使其具有了良好的扩展性以及最大程度上降低了耦合。 关键词：管理信息系统；J2EE; Struts；Hibernate；
2-数字化转型对企业劳动力就业的影响的研究数据（2001-2021年）.zip
11-07
随着数字技术和企业数字化转型的推进，企业的人力资源管理方式也在不断的变化，尤其是企业数字化转型对劳动力就业产生了深远的影响。 传统制造企业的工作模式一般是人工操作，处于低劳动力成本下的位置，而数字化转型要求企业应用物联网、云计算、大数据等先进技术，提高生产效率和减少人力成本。 数字化转型对企业劳动力就业的影响是多方面的，除替代性影响外，还会给企业带来新的机会，促进员工自我提升和企业人力资源管理意识的提高。本数据的整理让大家能够更清晰了解数字化转型对有关企业劳动力就业的影响。 相关数据指标 企业年龄 ， 资产负债率 ， 流动比率 ， 股权集中度 ， 所有制性质， 总资产收益率， 地区人均GDP
手势交互的可用性测试与评估.docx
11-07
手势交互的可用性测试与评估.docx
【java毕业设计】汽车在线销售系统源码（ssm+jsp+mysql+说明文档+LW）.zip
11-07
功能说明： 汽车在线销售系统的主要使用者分为管理员：个人中心、用户管理、车辆信息管理 、汽车信息管理 、汽车类型管理、汽车颜色管理、入库记录管理、出库记录管理、车辆购买管理、运输收费管理、订单状态管理管理、留言板管理、系统管理、管理员管理、留言管理等等。用户：个人中心、车辆购买、运输收费管理、订单状态管理、我的收藏管理等功能。首页前台功能：首页、汽车信息、新闻资讯、留言反馈、我的收藏通过这些功能模块的设计，基本上实现了整个汽车在线销售系统的过程。 环境说明： 开发语言：java 框架：ssm jdk版本：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse 部署容器：tomcat7+
在线测试管理系统 SSM毕业设计 附带论文.zip
11-07
在线测试管理系统 SSM毕业设计 附带论文 启动教程:https://www.bilibili.com/video/BV1GK1iYyE2B
几套嵌入式-真实简历.zip
最新发布
11-07
几套嵌入式-真实简历.zip
联想电脑的bios设置
11-07
联想电脑的bios设置、图文都有
网络拓扑结构优化.docx
11-07
网络拓扑结构优化.docx
【java毕业设计】职称评审管理系统源码（springboot+vue+mysql+说明文档+LW）.zip
11-07
功能说明： 管理员：首页、个人中心、用户管理、评审员管理、省份管理、评审条件管理、职称申请管理、结果公布管理、论坛管理、系统管理。 评审员：首页、个人中心、职称申请管理、结果公布管理。 用户：首页、个人中心、职称申请管理、结果公布管理、我的收藏管理。 前台首页：首页、评审条件、论坛信息、系统公告、个人中心、后台管理、客服功能等功能模块。 环境说明： 开发语言：java jdk：jdk1.8 数据库：mysql 5.7+ 数据库工具：Navicat11+ 管理工具：maven 开发工具：idea/eclipse
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值