package cn.ksource.web.facade.ciremind;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import cn.ksource.beans.GG_RECORD;
|
import cn.ksource.beans.SC_PARTNER_CUSTOMER_INFO;
|
import cn.ksource.beans.SC_WORKFLOW_CI_REMIND;
|
import cn.ksource.beans.WORKFLOW_BASE;
|
import cn.ksource.beans.WORKFLOW_NODE;
|
import cn.ksource.core.dao.BaseDao;
|
import cn.ksource.core.dao.SqlParameter;
|
import cn.ksource.core.page.PageInfo;
|
import cn.ksource.core.util.ConvertUtil;
|
import cn.ksource.core.util.DateUtil;
|
import cn.ksource.core.util.JsonUtil;
|
import cn.ksource.core.util.StringUtil;
|
import cn.ksource.core.web.SysInfoMsg;
|
import cn.ksource.core.web.WebUtil;
|
import cn.ksource.core.workflow.NodeAnswerEntity;
|
import cn.ksource.core.workflow.NodeFinishEntity;
|
import cn.ksource.core.workflow.WorkflowCoreService;
|
import cn.ksource.web.Constants;
|
import cn.ksource.web.entity.WorkFlowSupportEntity;
|
import cn.ksource.web.service.order.OrderService;
|
import cn.ksource.web.service.record.RecordService;
|
import cn.ksource.web.service.workFlowSupport.WorkFlowSupportService;
|
import cn.ksource.web.util.DateParepareUtil;
|
|
@Service("ciRemindFacade")
|
public class CiRemindFacadeImpl implements CiRemindFacade {
|
@Autowired
|
private BaseDao baseDao;
|
@Autowired
|
private WorkflowCoreService workflowCoreService;
|
@Autowired
|
private WorkFlowSupportService workFlowSupportService;
|
@Autowired
|
private OrderService orderService;
|
@Autowired
|
private RecordService recordService;
|
|
@Override
|
public PageInfo queryMyRemindData(PageInfo pageInfo,Map<String, String> param) {
|
String userId=param.get("userId");
|
String flowState = param.get("flowState");
|
String nodeState = param.get("nodeState");
|
String customerId = param.get("customerId");
|
String subCustomerId = param.get("subCustomerId");
|
String orderCode = param.get("orderCode");
|
|
|
param.put("userId", userId);
|
param.put("nodeState", nodeState);
|
param.put("flowState", flowState);
|
param.put("customerId", customerId);
|
param.put("subCustomerId", subCustomerId);
|
param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
|
param.put("orderCode", "%"+orderCode+"%");
|
|
StringBuilder builder = getMyRemindSql(param);
|
return baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), param);
|
|
}
|
|
@Override
|
public int queryMyRemindCount(Map<String, String> param) {
|
String userId=param.get("userId");
|
String flowState = param.get("flowState");
|
String nodeState = param.get("nodeState");
|
String customerId = param.get("customerId");
|
String subCustomerId = param.get("subCustomerId");
|
String orderCode = param.get("orderCode");
|
|
|
param.put("userId", userId);
|
param.put("nodeState", nodeState);
|
param.put("flowState", flowState);
|
param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
|
param.put("orderCode", "%"+orderCode+"%");
|
param.put("customerId", customerId);
|
param.put("subCustomerId", subCustomerId);
|
|
|
StringBuilder builder = getMyRemindSql(param);
|
String sql = "select count(*) from ( " + builder.toString() + " ) t";
|
return baseDao.queryForInteger(sql,param);
|
}
|
|
/**
|
* 获取我的工单
|
* @param request
|
* @return
|
*/
|
private StringBuilder getMyRemindSql(Map<String, String> param){
|
String userId=param.get("userId");
|
String flowState = param.get("flowState");
|
String nodeState = param.get("nodeState");
|
String customerId = param.get("customerId");
|
String subCustomerId = param.get("subCustomerId");
|
|
|
StringBuilder builder = new StringBuilder();
|
builder.append(" select n.*,b.WFNAME,b.CREATERNAME,b.CREATETIME,b.CURRENT_NODE_NAME,b.BUSINESSTYPE, ");
|
builder.append(" t.PLAN_EXECUTION_DATE, r.ORDER_CODE,r.ID ORDERID,r.SERVICE_CONTENT,b.CUSTOMER_NAME,b.SUB_CUSTOMER_NAME,B.WFSTATE ");
|
builder.append(" from SC_WORKFLOW_CI_REMIND r ");
|
builder.append(" inner join WORKFLOW_BASE B on r.FLOW_ID = b.ID ");
|
builder.append(" inner join CI_REMIND_TIMERTASK t on r.FLOW_ID = t.FLOW_ID ");
|
builder.append(" inner join ");
|
builder.append(" ( ");
|
builder.append(" select * from ( ");
|
builder.append(" select ID NODEID, CREATETIME NODETIME,FLOWSTATE NODESTATE,FLOWID from WORKFLOW_NODE ");
|
builder.append(" where CURRENT_DEALER_ID = :userId ");
|
//环节状态
|
if(StringUtil.isNotBlank(nodeState)){
|
builder.append("and FLOWSTATE =:nodeState ");
|
|
}
|
builder.append(" order by FLOWSTATE asc ");
|
builder.append(" ) t ");
|
builder.append(" group by FLOWID ");
|
builder.append(" ) n ");
|
builder.append(" on b.ID = n.FLOWID ");
|
//工单类型
|
builder.append(" where b.BUSINESSTYPE = :businessType");
|
//工单状态
|
if(StringUtil.notEmpty(flowState)) {
|
builder.append(" AND b.WFSTATE =:flowState ");
|
|
}
|
|
//客户
|
if(StringUtil.isNotBlank(customerId)) {
|
builder.append(" AND b.CUSTOMER_ID = :customerId ");
|
}
|
//下属单位
|
if(StringUtil.isNotBlank(subCustomerId)) {
|
builder.append(" AND b.SUB_CUSTOMER_ID = :subCustomerId ");
|
}
|
|
//工单编号
|
String orderCode = param.get("orderCode");
|
if(StringUtil.notEmpty(orderCode)) {
|
builder.append(" AND r.ORDER_CODE LIKE :orderCode");
|
|
}
|
builder.append(" order by n.NODESTATE ASC,n.NODETIME desc,b.CREATETIME desc ");
|
return builder;
|
}
|
/**
|
* 例行巡检基本信息
|
*/
|
@Override
|
public Map queryRemindInfo(String orderId) {
|
String sql = " select b.WFSTATE,h.*,t.PLAN_EXECUTION_DATE from SC_WORKFLOW_CI_REMIND h ,CI_REMIND_TIMERTASK t, WORKFLOW_BASE b " +
|
" where h.FLOW_ID = t.FLOW_ID and b.ID=h.FLOW_ID and h.id = :orderId ";
|
return baseDao.queryForMap(sql,new SqlParameter("orderId",orderId));
|
}
|
/**
|
* 工单响应
|
* @param request
|
* @return
|
*/
|
@Override
|
public boolean answerSubmit(Map<String, String> param) {
|
String orderId = param.get("orderId");
|
SC_WORKFLOW_CI_REMIND remind = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById();
|
String nodeId = param.get("nodeId");
|
WORKFLOW_BASE base = new WORKFLOW_BASE(remind.getFlow_id()).getInstanceById();
|
WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
|
NodeAnswerEntity entity = new NodeAnswerEntity();
|
|
entity.setUser_id(param.get("ID"));
|
entity.setUser_name(param.get("ZSXM"));
|
|
boolean flag = workflowCoreService.answerNode(base, node, entity);
|
return flag;
|
}
|
|
/**
|
* 关闭流程
|
*/
|
public void closeWorkFlowSubmit(Map<String, String> param){
|
String orderId = param.get("orderId");
|
|
String closeNote = param.get("closeNote");
|
String nodeId = param.get("nodeId");
|
|
String userName = param.get("userName");
|
|
SC_WORKFLOW_CI_REMIND order = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById();
|
WORKFLOW_BASE base = new WORKFLOW_BASE(order.getFlow_id()).getInstanceById();
|
NodeFinishEntity finishEntity = new NodeFinishEntity();
|
finishEntity.setDeal_result(1);
|
finishEntity.setDeal_note_title(userName+"关闭了工单");
|
finishEntity.setDeal_note(closeNote);
|
WORKFLOW_NODE node = new WORKFLOW_NODE(nodeId).getInstanceById();
|
workflowCoreService.finishNode(base, node, finishEntity);
|
workflowCoreService.closeWorkFlow(base);
|
}
|
/**
|
* 服务台调度 提交
|
*/
|
@Override
|
public SysInfoMsg doServerDispatch(Map<String, String> param,SC_WORKFLOW_CI_REMIND remind,String[] ciIdAry) {
|
String orderId =param.get("orderId");
|
String nodeId =param.get("nodeId");
|
String executorIds = param.get("executorIds");
|
String executorNames = param.get("executorNames");
|
String main_executorId = param.get("main_executorId");
|
String flowNote = param.get("flowNote");
|
String dealUserName = "";
|
|
String flowId = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().getFlow_id();
|
//更新业务表数据
|
remind.setId(orderId).update();
|
//设定执行人
|
List<Map> userList = new ArrayList<Map>();
|
String[] executorIdAry = executorIds.split(",");
|
String[] executorNameAry = executorNames.split(",");
|
|
Map cacheuser = new HashMap();
|
|
for(int i=0;i<executorIdAry.length;i++){
|
Map tempMap = new HashMap();
|
tempMap.put("USER_ID", executorIdAry[i]);
|
tempMap.put("USER_NAME", executorNameAry[i]);
|
if(executorIdAry[i].equals(main_executorId)){
|
tempMap.put("IS_ADMIN", "1");
|
dealUserName=executorNameAry[i];
|
|
}
|
userList.add(tempMap);
|
}
|
|
|
|
String userId=param.get("ID");
|
String userName=param.get("ZSXM");
|
|
|
Map flowMsg = getFlowMsg(flowId,userId);
|
String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
|
String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
|
|
//增加处理记录
|
GG_RECORD record = new GG_RECORD();
|
record.setDeal_content(nodeName+"："+userName+",将问题指派给了,"+dealUserName);
|
record.setDeal_time(DateUtil.getCurrentDate14());
|
record.setDeal_user_id(userId);
|
record.setDeal_user_name(userName);
|
record.setBusiness_id(flowId);
|
record.setNode_id(nodeId).setNode_name(nodeName);
|
recordService.addRecord(record);
|
|
//环节流转
|
WorkFlowSupportEntity support = new WorkFlowSupportEntity();
|
support.setFlowId(flowId);
|
support.setNodeId(nodeId);
|
support.setNote(flowNote);
|
support.setUserName(userName);
|
support.setUserId(userId);
|
support.setNextNodeTemplateId(Constants.REMIND_DEAL);
|
support.setNextUserList(userList);
|
support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
|
SysInfoMsg msg = workFlowSupportService.doOrderFlow(support);
|
addPatrolCi(orderId,ciIdAry);
|
return msg;
|
}
|
|
/**
|
* 通过orderid获取流程信息
|
*/
|
@Override
|
public Map getFlowMsg(String flowId,String userId) {
|
String selectSql = "SELECT * FROM WORKFLOW_NODE WHERE FLOWID = :flowId AND CURRENT_DEALER_ID = :userId AND FLOWSTATE <> 3 ";
|
return baseDao.queryForMap(selectSql,new SqlParameter("flowId",flowId).addValue("userId", userId));
|
}
|
|
@Override
|
public void addPatrolCi(String orderId, String[] ciIdAry) {
|
baseDao.execute("delete from SC_WORKFLOW_CI_REMIND_DETAIL where order_id = :orderId", new SqlParameter("orderId",orderId));
|
if(ciIdAry!=null&&ciIdAry.length>0){
|
ArrayList<SqlParameter> paramList = new ArrayList<SqlParameter>();
|
for(int i=0;i<ciIdAry.length;i++){
|
SqlParameter param = new SqlParameter();
|
param.addValue("id", StringUtil.getUUID())
|
.addValue("ciId", ciIdAry[i])
|
.addValue("orderId", orderId);
|
paramList.add(param);
|
}
|
String sql = " insert into SC_WORKFLOW_CI_REMIND_DETAIL (ID,CI_ID,ORDER_ID,DEAL_STATE) " +
|
" values (:id,:ciId,:orderId,3)";
|
baseDao.executeBatch(sql, paramList);
|
}
|
}
|
/**
|
* 获取例行巡检设备列表
|
*/
|
@Override
|
public List<Map> getRemindCiList(String orderId) {
|
StringBuilder sql = new StringBuilder();
|
sql.append(" select b.ID CIID,r.USER_NAME,r.DEAL_STATE,r.ID,c.NAME CATENAME,c.ID CATEID,b.CINAME,b.SEARCHCODE,b.POSITION from SC_WORKFLOW_CI_REMIND_DETAIL r ");
|
sql.append(" inner join cmdb_ci_base b ");
|
sql.append(" on r.CI_ID = b.ID ");
|
sql.append(" inner join cmdb_ci_category c ");
|
sql.append(" on b.LV3_ID = c.ID ");
|
sql.append(" where r.ORDER_ID = :orderId ");
|
return baseDao.queryForList(sql.toString(),new SqlParameter("orderId",orderId));
|
}
|
|
@Override
|
public List<Map> getRemindCiList(Map param) {
|
String sql = " select c.business_id cateId from ci_remind_timertask a , ci_remind_customer_item b, ci_remind_item c "
|
+ " where a.customer_item_id=b.id and b.item_id = c.id and a.flow_id = :flowId ";
|
String cateId = baseDao.queryForString(sql,param);
|
param.put("cateId",cateId);
|
|
String ciIds = ConvertUtil.obj2Str(param.get("ciIds"));
|
sql = " select b.*,c.NAME CATENAME from cmdb_ci_base b " +
|
" inner join cmdb_ci_category c on b.LV3_ID = c.ID " +
|
" inner join CI_REMIND_CILIST r on r.CI_ID = b.id " +
|
" where b.CUS_ID = :customerId and b.SUB_CUS_ID=:subCustomerId " ;
|
if(StringUtil.isNotBlank(ciIds)){
|
sql = sql + " and b.ID not in (:ciIds) ";
|
param.put("ciIds", Arrays.asList(ciIds.split(",")));
|
}
|
if (StringUtil.notEmpty(cateId)) {
|
sql = sql + " and ( b.lv3_id=:cateId OR b.lv2_id=:cateId )";
|
}
|
sql = sql + " and b.STATE=1 group by b.id ";
|
return baseDao.queryForList(sql,param);
|
}
|
|
@Override
|
public Map getPatrolInfo(String patrolId) {
|
String sql = " select * from SC_WORKFLOW_CI_REMIND_DETAIL where id = :patrolId";
|
SqlParameter param = new SqlParameter();
|
param.addValue("patrolId", patrolId);
|
return baseDao.queryForMap(sql, param);
|
}
|
|
@Override
|
public SysInfoMsg doEngineerPatrol(Map<String, String> param) {
|
String orderId = ConvertUtil.obj2StrBlank(param.get("orderId"));
|
String nodeId = ConvertUtil.obj2StrBlank(param.get("nodeId"));
|
String note = ConvertUtil.obj2StrBlank(param.get("flowNote"));
|
String summary = ConvertUtil.obj2StrBlank(param.get("summary"));
|
|
|
String userName = param.get("ZSXM");
|
String userId = param.get("Id");
|
|
new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().setOrder_note(summary).update();
|
String flowId = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().getFlow_id();
|
|
Map flowMsg = getFlowMsg(flowId,userId);
|
String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
|
String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
|
|
//增加处理记录
|
GG_RECORD record = new GG_RECORD();
|
record.setDeal_content(nodeName+"："+userName+",已处理维护执行");
|
record.setDeal_time(DateUtil.getCurrentDate14());
|
record.setDeal_user_id(userId);
|
record.setDeal_user_name(userName);
|
record.setBusiness_id(flowId);
|
record.setNode_id(nodeId).setNode_name(nodeName);
|
recordService.addRecord(record);
|
|
//环节流转
|
WorkFlowSupportEntity support = new WorkFlowSupportEntity();
|
support.setFlowId(flowId);
|
support.setNodeId(nodeId);
|
support.setNote(note);
|
support.setUserName(userName);
|
support.setUserId(userId);
|
support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
|
Integer is_admin = new WORKFLOW_NODE(nodeId).getInstanceById().getIs_admin();
|
if(is_admin!=null&&is_admin==1){
|
support.setNextNodeTemplateId(Constants.REMIND_APPROVE);
|
support.setEverDealflag(true);
|
support.setEverNodeTemplateId(Constants.REMIND_DISPATCH);
|
}
|
SysInfoMsg msg = workFlowSupportService.doOrderFlow(support);
|
return msg;
|
}
|
/**
|
* 回退
|
*/
|
@Override
|
public void doSendback(Map<String, String> param) {
|
String orderId = param.get("orderId");
|
String nodeId = param.get("nodeId");
|
String lastNodeTemplateId = param.get("lastNodeTemplateId");
|
String note = param.get("backNote");
|
|
String userName = ConvertUtil.obj2StrBlank(param.get("ZSXM"));
|
String userId = ConvertUtil.obj2StrBlank(param.get("ID"));
|
|
String flowId = param.get("flowId");
|
|
WorkFlowSupportEntity support = new WorkFlowSupportEntity();
|
support.setFlowId(flowId);
|
support.setNodeId(nodeId);
|
support.setUserName(userName);
|
support.setUserId(userId);
|
support.setNote(note);
|
support.setEverNodeTemplateId(lastNodeTemplateId);
|
support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
|
SysInfoMsg msg = workFlowSupportService.doOrderSendback(support);
|
}
|
/**
|
* 结束流程
|
*/
|
@Override
|
public SysInfoMsg doEndRemindFlow(Map<String, String> param) {
|
String orderId = ConvertUtil.obj2StrBlank(param.get("orderId"));
|
String nodeId = ConvertUtil.obj2StrBlank(param.get("nodeId"));
|
String note = ConvertUtil.obj2StrBlank(param.get("flowNote"));
|
String userName = param.get("ZSXM").toString();
|
String userId = param.get("Id").toString();
|
String flowId = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().getFlow_id();
|
|
Map flowMsg = getFlowMsg(flowId,userId);
|
String nodeid = ConvertUtil.obj2StrBlank(flowMsg.get("ID"));
|
String nodeName = ConvertUtil.obj2StrBlank(flowMsg.get("NODENAME"));
|
|
//增加处理记录
|
GG_RECORD record = new GG_RECORD();
|
record.setDeal_content(nodeName+"："+userName+",已审核");
|
record.setDeal_time(DateUtil.getCurrentDate14());
|
record.setDeal_user_id(userId);
|
record.setDeal_user_name(userName);
|
record.setBusiness_id(flowId);
|
record.setNode_id(nodeId).setNode_name(nodeName);
|
recordService.addRecord(record);
|
|
|
//环节流转
|
WorkFlowSupportEntity support = new WorkFlowSupportEntity();
|
support.setFlowId(flowId);
|
support.setNodeId(nodeId);
|
support.setNote(note);
|
support.setUserName(userName);
|
support.setUserId(userId);
|
support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
|
support.setFlowEndflag(true);
|
SysInfoMsg msg = workFlowSupportService.doOrderFlow(support);
|
Long endTime = DateUtil.getCurrentDate14();
|
new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById().setFinish_time(endTime).update();
|
return msg;
|
}
|
|
@Override
|
public Map getRemindeItem(Map<String, String> param) {
|
String flowId= param.get("flowId");
|
param.put("flowId",flowId);
|
StringBuilder sql = new StringBuilder();
|
sql.append("SELECT * FROM SC_WORKFLOW_CI_REMIND c ");
|
sql.append(" WHERE c.FLOW_ID=:flowId");
|
Map remindMap=baseDao.queryForMap(sql.toString(), param);
|
Map map =new HashMap();
|
if(remindMap!=null && remindMap.size()>0){
|
//服务工程师
|
StringBuilder selSql=new StringBuilder();
|
selSql.append("SELECT A.CURRENT_DEALER_NAME,B.SJHM FROM workflow_node A,GG_USER B WHERE A.CURRENT_DEALER_ID=B.ID AND A.FLOWID=:flowId AND A.IS_ADMIN=1 AND A.NODE_TEMPLATE_ID=:nodeId");
|
Map dealerMap=baseDao.queryForMap(selSql.toString(),new SqlParameter().addValue("flowId", flowId).addValue("nodeId", Constants.REMIND_DEAL));
|
System.out.println(dealerMap);
|
map.put("dealerMap", dealerMap);
|
//应维护配置数量
|
sql.setLength(0);
|
param.put("orderId",String.valueOf(remindMap.get("ID")));
|
sql.append("SELECT ID FROM SC_WORKFLOW_CI_REMIND_DETAIL WHERE ORDER_ID=:orderId");
|
List detailCountList=baseDao.queryForList(sql.toString(),param);
|
map.put("detailCount", detailCountList.size());
|
if(detailCountList==null || detailCountList.size()==0)map.put("detailCount", 0);
|
//实际维护配置数量
|
sql.setLength(0);
|
param.put("state",String.valueOf(Constants.CI_REMIND_DETAIL_STATE_ONE));
|
sql.append("SELECT ID FROM SC_WORKFLOW_CI_REMIND_DETAIL WHERE ORDER_ID=:orderId AND DEAL_STATE=:state");
|
List detailStateCountList=baseDao.queryForList(sql.toString(),param);
|
map.put("detailStateCount", detailStateCountList.size());
|
if(detailStateCountList==null || detailStateCountList.size()==0)map.put("detailStateCount", 0);
|
//审核人
|
sql.setLength(0);
|
sql.append("SELECT * FROM WORKFLOW_NODE WHERE NODE_TEMPLATE_ID=:templateId AND FLOWID=:flowId ORDER BY CREATETIME DESC");
|
param.put("templateId", "04e5ae6861fd4ef6bbc521e30b4d11bc");
|
param.put("flowId", flowId);
|
List<Map> nodeList=baseDao.queryForList(sql.toString(), param);
|
if(nodeList!=null && nodeList.size()>0){
|
map.put("node", nodeList.get(0));
|
}
|
//文档列表
|
String fileSql = "select * from GG_FILES where EXTEND1=:BUSINESS_ID AND DEL_FLAG = 1 order by ORDERNUM";
|
List<Map> fileList = baseDao.queryForList(fileSql,new SqlParameter("BUSINESS_ID",flowId));
|
map.put("fileList", fileList);
|
//涉及工单列表
|
List<Map> orderList=orderService.queryLinkOrders(flowId);
|
if(orderList!=null && orderList.size()>0){
|
for(Map orderMap:orderList){
|
orderMap.put("WFSTATE", Constants.getWORKFLOW_BASE_WFSTATE_Label(orderMap.get("WFSTATE").toString()));
|
}
|
}
|
map.put("orderList", orderList);
|
}
|
map.put("remindMap", remindMap);
|
return map;
|
}
|
|
@Override
|
public Map getRemindDetail(Map<String, String> param) {
|
String orderId=param.get("orderId");
|
param.put("orderId", orderId);
|
StringBuilder sql=new StringBuilder();
|
sql.append("SELECT c.USER_NAME,c.ORDER_NOTE,b.CINAME,b.POSITION,c.FINISH_TIME,c.DEAL_STATE FROM SC_WORKFLOW_CI_REMIND_DETAIL c,CMDB_CI_BASE b ");
|
sql.append(" WHERE c.CI_ID=b.ID AND c.ORDER_ID=:orderId");
|
List<Map> detailList=baseDao.queryForList(sql.toString(),param);
|
if(detailList!=null && detailList.size()>0){
|
for(Map map :detailList){
|
map.put("DEAL_STATE", Constants.getmapCI_REMIND_DETAIL_STATE(Integer.parseInt(map.get("DEAL_STATE").toString())));
|
}
|
}
|
SC_WORKFLOW_CI_REMIND remind = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById();
|
Map map = new HashMap();
|
map.put("remind", remind);
|
map.put("detailList", detailList);
|
return map;
|
}
|
|
//例行维护管理
|
|
|
@Override
|
public int queryJxzRemindOrderCount(Map<String, String> param) {
|
StringBuilder buffer = new StringBuilder("SELECT COUNT(b.ID) FROM WORKFLOW_BASE b WHERE b.BUSINESSTYPE = :businessType AND b.WFSTATE = :wfstate ");
|
|
return baseDao.queryForInteger(buffer.toString(),new SqlParameter("businessType",Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND).addValue("wfstate", Constants.WORKFLOW_BASE_WFSTATE_DOING));
|
}
|
|
@Override
|
public Map queryNodeCount(Map<String, String> param) {
|
StringBuilder buffer = new StringBuilder("SELECT n.NODE_TEMPLATE_ID,COUNT(n.NODE_TEMPLATE_ID) AS num FROM WORKFLOW_NODE n, WORKFLOW_BASE b WHERE b.CURRENT_NODE_ID = n.ID and b.BUSINESSTYPE = :businessType AND b.WFSTATE = :wfstate ");
|
|
buffer.append(" GROUP BY n.NODE_TEMPLATE_ID ");
|
List<Map> list = baseDao.queryForList(buffer.toString(),new SqlParameter("businessType",Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND).addValue("wfstate", Constants.WORKFLOW_BASE_WFSTATE_DOING));
|
Map resultMap = new HashMap();
|
if(null != list && list.size()>0) {
|
for(Map map : list) {
|
resultMap.put(map.get("NODE_TEMPLATE_ID"), map.get("num"));
|
}
|
}
|
return resultMap;
|
}
|
|
@Override
|
public PageInfo queryRemindOrderList(PageInfo pageInfo,Map<String, String> param) {
|
|
StringBuilder builder = new StringBuilder();
|
String flowState = param.get("flowState");
|
String orderCode = param.get("orderCode");
|
String customerId = param.get("customerId");
|
String subCustomerId = param.get("subCustomerId");
|
|
String nodeTempId = param.get("nodeTempId");
|
|
param.put("customerId", customerId);
|
param.put("subCustomerId", subCustomerId);
|
param.put("flowState", flowState);
|
param.put("orderCode", "%"+orderCode+"%");
|
param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
|
param.put("nodeTempId", nodeTempId);
|
|
builder = getAllRemindSql(param);
|
return baseDao.queryforSplitPageInfo(pageInfo, builder.toString(), param);
|
}
|
|
|
@Override
|
public int queryRemindOrderCount(Map<String, String> param) {
|
StringBuilder builder = new StringBuilder();
|
String flowState = param.get("flowState");
|
String orderCode = param.get("orderCode");
|
String customerId = param.get("customerId");
|
String subCustomerId = param.get("subCustomerId");
|
|
param.put("flowState", flowState);
|
param.put("customerId", customerId);
|
param.put("subCustomerId", subCustomerId);
|
param.put("orderCode", "%"+orderCode+"%");
|
param.put("businessType", String.valueOf(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND));
|
String nodeTempId = param.get("nodeTempId");
|
param.put("nodeTempId", nodeTempId);
|
|
builder = getAllRemindSql(param);
|
String sql = "select count(*) from ( " + builder.toString() + " ) t" ;
|
return baseDao.queryForInteger(sql.toString(),param);
|
}
|
|
/**
|
* 服务台工单列表
|
* @param request
|
* @return
|
*/
|
private StringBuilder getAllRemindSql(Map<String, String> param){
|
String flowState = param.get("flowState");
|
String customerId = param.get("customerId");
|
String subCustomerId = param.get("subCustomerId");
|
String nodeTempId = param.get("nodeTempId");
|
|
|
StringBuilder builder = new StringBuilder();
|
builder.append(" select b.ID FLOWID,b.WFNAME,b.CREATERNAME,b.CREATETIME,b.CURRENT_NODE_NAME,b.BUSINESSTYPE, ");
|
builder.append(" t.PLAN_EXECUTION_DATE,r.ORDER_CODE,r.ID ORDERID,r.SERVICE_CONTENT,b.CUSTOMER_NAME,b.SUB_CUSTOMER_NAME,B.WFSTATE ");
|
builder.append(" from SC_WORKFLOW_CI_REMIND r ");
|
builder.append(" inner join WORKFLOW_BASE b on r.FLOW_ID = b.ID ");
|
builder.append(" inner join CI_REMIND_TIMERTASK t on r.FLOW_ID = t.FLOW_ID ");
|
|
//工单类型
|
builder.append(" where b.BUSINESSTYPE = :businessType");
|
//工单状态
|
if(StringUtil.notEmpty(flowState)) {
|
builder.append(" AND b.WFSTATE =:flowState ");
|
}
|
|
|
//客户
|
if(StringUtil.isNotBlank(customerId)) {
|
builder.append(" AND b.CUSTOMER_ID = :customerId ");
|
}
|
//下属单位
|
if(StringUtil.isNotBlank(subCustomerId)) {
|
builder.append(" AND b.SUB_CUSTOMER_ID = :subCustomerId ");
|
|
}
|
//工单编号
|
String orderCode = param.get("orderCode");
|
if(StringUtil.notEmpty(orderCode)) {
|
builder.append(" AND r.ORDER_CODE LIKE :orderCode");
|
}
|
|
if(StringUtil.notEmpty(nodeTempId)) {
|
builder.append(" AND EXISTS (SELECT n.ID FROM WORKFLOW_NODE n WHERE b.CURRENT_NODE_ID = n.ID AND n.NODE_TEMPLATE_ID = :nodeTempId ) ");
|
}
|
|
builder.append(" order by b.CREATETIME desc,t.PLAN_EXECUTION_DATE desc ");
|
return builder;
|
}
|
|
@Override
|
public Map getRemindItemSubTimerTaskData(String customerId, String month) {
|
//查询该客户下的所有下属单位
|
String sql="SELECT * FROM SC_PARTNER_CUSTOMER_SUB WHERE CUSTOMER_ID=:customerId AND DEL_FLAG=1";
|
List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));
|
|
Map currentCustomer = new HashMap();
|
currentCustomer.put("ID", customerId);
|
currentCustomer.put("CUSTOMER_NAME", new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById().getCustomer_name());
|
subList.add(0, currentCustomer);
|
|
|
if(!StringUtil.notEmpty(month)) {
|
month = DateUtil.getCurrentDate6().toString();
|
}
|
|
String monthBeginDay = month+"01";
|
//查询当月的所有天数
|
String monthLastDay = DateParepareUtil.lastDayMonth(month, "yyyyMM", "yyyyMMdd");
|
|
|
List<String> days = DateUtil.getBetweenTwoDateCycleList(monthBeginDay, monthLastDay, 2,1, "yyyyMMdd","yyyyMMdd");
|
if(subList!=null && subList.size()>0){
|
for(Map subMap:subList){
|
//查询执行计划
|
StringBuilder taskSql=new StringBuilder("SELECT A.PLAN_EXECUTION_DATE,A.STATE,A.FLOW_ID,A.SUB_CUSTOMER_ID FROM CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B WHERE A.CUSTOMER_ITEM_ID=B.ID ");
|
taskSql.append(" AND A.CUSTOMER_ID=:customerId AND A.SUB_CUSTOMER_ID=:subId AND A.PLAN_EXECUTION_DATE>:beginDate AND A.PLAN_EXECUTION_DATE<:endDate");
|
List<Map> taskList=baseDao.queryForList(taskSql.toString(), new SqlParameter().addValue("customerId", customerId).addValue("subId", subMap.get("ID"))
|
.addValue("beginDate", monthBeginDay).addValue("endDate", monthLastDay));
|
List<Map> isMarkList = new ArrayList<Map>();
|
for(String day:days){
|
Map markMap=new HashMap();
|
|
markMap.put("day", day);
|
|
|
|
int zjh = 0;
|
int yzx = 0;
|
if(taskList!=null && taskList.size()>0){
|
List<Map> plans = new ArrayList<Map>();
|
for(Map map:taskList){
|
Map plan = new HashMap();
|
|
|
|
Integer task=2;
|
Integer mark=0;
|
String orderId = new String();
|
String plan_execution_date = ConvertUtil.obj2StrBlank(map.get("PLAN_EXECUTION_DATE"));
|
if(plan_execution_date.equals(day)){
|
task=1;
|
if(String.valueOf(map.get("STATE")).equals("1")){
|
mark=1;
|
}else if(String.valueOf(map.get("STATE")).equals("2")){
|
yzx++;
|
mark=2;
|
orderId = ConvertUtil.obj2StrBlank(map.get("FLOW_ID"));
|
}
|
zjh++;
|
}
|
plan.put("task", String.valueOf(task));
|
plan.put("mark", String.valueOf(mark));
|
plan.put("orderId", orderId);
|
plans.add(plan);
|
}
|
markMap.put("plans", plans);
|
}
|
markMap.put("zjh", zjh);
|
markMap.put("yzx", yzx);
|
isMarkList.add(markMap);
|
}
|
subMap.put("isMarkList", isMarkList);
|
}
|
}
|
System.out.println(subList);
|
Map map = new HashMap();
|
map.put("subList", subList);
|
map.put("days", days);
|
return map;
|
}
|
|
@Override
|
public List<Map> querySubCustomerRemindPlanForDay(Map<String, String> param) {
|
String customerId = param.get("customerId");
|
String subCustomerId = param.get("subCustomerId");
|
String day = param.get("day");
|
String selectSql = "SELECT A.*,C.ITEM_NAME,C.ITEM_NOTE ,W.ID ORDER_ID FROM " +
|
" CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B,CI_REMIND_ITEM C ,SC_WORKFLOW_CI_REMIND W " +
|
" WHERE A.CUSTOMER_ITEM_ID = B.ID AND B.ITEM_ID = C.ID AND A.FLOW_ID=W.FLOW_ID " +
|
" AND A.CUSTOMER_ID = :customerId AND A.SUB_CUSTOMER_ID = :subCustomerId " +
|
" AND A.PLAN_EXECUTION_DATE = :day AND B.USING_STATE = 1 " +
|
" ORDER BY A.PLAN_EXECUTION_DATE DESC ";
|
//Map paramMap = new HashMap();
|
param.put("customerId", customerId);
|
param.put("subCustomerId", subCustomerId);
|
param.put("day", day);
|
|
List<Map> plans = baseDao.queryForList(selectSql,param);
|
return plans;
|
}
|
|
@Override
|
public PageInfo getRemindItemData(PageInfo pageInfo,Map<String, String> param) {
|
String customerId=param.get("customerId");
|
String itemName=param.get("itemName");
|
String subId=param.get("subId");
|
StringBuilder sql = new StringBuilder();
|
sql.append("SELECT A.*,B.ID AS PROJECT_ITEM_ID,S.CUSTOMER_NAME " +
|
" FROM (SELECT D.ID,D.CUSTOMER_NAME FROM SC_PARTNER_CUSTOMER_SUB D UNION ALL SELECT E.ID,E.CUSTOMER_NAME FROM SC_PARTNER_CUSTOMER_INFO E) S, CI_REMIND_ITEM A ," +
|
" CI_REMIND_CUSTOMER_ITEM B LEFT JOIN CI_REMIND_CUSTOMER_ITEM_CYCLE C ON C.PROJECT_ITEM_ID=B.ID " +
|
" WHERE A.ID=B.ITEM_ID AND S.ID=C.SUB_CUSTOMER_ID AND B.USING_STATE=1 ");
|
if(StringUtil.notEmpty(itemName)){
|
sql.append(" AND A.ITEM_NAME LIKE :itemName");
|
}
|
|
if(StringUtil.notEmpty(subId)){
|
sql.append(" AND C.SUB_CUSTOMER_ID=:subId");
|
}
|
|
sql.append(" AND B.CUSTOMER_ID=:customerId ");
|
sql.append(" ORDER BY A.ITEM_TYPE,ORDER_NUM ASC");
|
//SqlParameter paramMap = new SqlParameter();
|
param.put("itemName", "%"+itemName+"%");
|
param.put("subId", subId);
|
param.put("customerId", customerId);
|
return baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), param);
|
}
|
|
@Override
|
public Integer getRemindItemCount(Map<String, String> param) {
|
String customerId=param.get("customerId");
|
String itemName=param.get("itemName");
|
String subId=param.get("subId");
|
StringBuilder sql = new StringBuilder();
|
sql.append("SELECT count(*) FROM CI_REMIND_ITEM A ,CI_REMIND_CUSTOMER_ITEM B LEFT JOIN CI_REMIND_CUSTOMER_ITEM_CYCLE C ON C.PROJECT_ITEM_ID=B.ID WHERE A.ID=B.ITEM_ID AND B.USING_STATE=1 ");
|
if(StringUtil.notEmpty(itemName)){
|
sql.append(" AND A.ITEM_NAME LIKE:itemName");
|
}
|
if(StringUtil.notEmpty(subId)){
|
sql.append(" AND C.SUB_CUSTOMER_ID=:subId");
|
}
|
sql.append(" AND B.CUSTOMER_ID=:customerId ");
|
//SqlParameter paramMap = new SqlParameter();
|
param.put("customerId", customerId);
|
param.put("itemName", "%"+itemName+"%");
|
param.put("subId", subId);
|
return baseDao.queryForInteger(sql.toString(), param);
|
}
|
|
@Override
|
public Map queryRemind(String customerItemId) {
|
String selectSql = "SELECT A.ID,A.ITEM_NAME,A.CYCLE,A.PRIORITY_LEVEL_ID,A.PRIORITY_LEVEL_NAME," +
|
" A.ITEM_NOTE,A.ORDER_NUM,A.STATE,A.BUSINESS_ID,A.BUSINESS_NAME,A.ITEM_TYPE,B.ID AS PROJECT_ITEM_ID,B.CUSTOMER_ID " +
|
" FROM CI_REMIND_ITEM A,CI_REMIND_CUSTOMER_ITEM B WHERE A.ID = B.ITEM_ID AND B.ID = :id ";
|
Map item = baseDao.queryForMap(selectSql,new SqlParameter("id",customerItemId));
|
return item;
|
}
|
|
/**
|
* 查询执行计划
|
* @param customerItemId
|
* @param customerId
|
* @param subCustomerId
|
* @return
|
*/
|
@Override
|
public List queryItemPlan(String customerItemId,String customerId,String subCustomerId) {
|
List result = new ArrayList();
|
if(StringUtil.notEmpty(customerId)) {
|
SC_PARTNER_CUSTOMER_INFO customer = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();
|
|
long beginTime = customer.getValid_begin_date();
|
long endTime = customer.getValid_end_date();
|
|
|
Map paramMap = new HashMap();
|
//查询所有已经生成的计划
|
String selectSql = "SELECT A.*,W.ID ORDER_ID " +
|
" FROM CI_REMIND_TIMERTASK A LEFT JOIN SC_WORKFLOW_CI_REMIND W ON A.FLOW_ID=W.FLOW_ID " +
|
" WHERE A.CUSTOMER_ITEM_ID = :customerItemId AND A.CUSTOMER_ID = :customerId ";
|
paramMap.put("customerId", customerId);
|
paramMap.put("customerItemId", customerItemId);
|
selectSql += " AND A.SUB_CUSTOMER_ID = :subId ";
|
if(StringUtil.notEmpty(subCustomerId)) {
|
paramMap.put("subId", subCustomerId);
|
} else {
|
paramMap.put("subId", customerId);
|
}
|
|
selectSql += " ORDER BY A.PLAN_EXECUTION_DATE ";
|
|
|
List<Map> plans = baseDao.queryForList(selectSql,paramMap);
|
|
Map<String,Map> cacheMap = new HashMap<String,Map>();
|
if(null!=plans && plans.size()>0) {
|
for(Map plan : plans) {
|
String day = ConvertUtil.obj2StrBlank(plan.get("PLAN_EXECUTION_DATE"));
|
cacheMap.put(day, plan);
|
}
|
}
|
|
|
//求出所有月份的集合
|
List<String> months = DateUtil.getBetweenTwoDateCycleList(ConvertUtil.obj2StrBlank(beginTime), ConvertUtil.obj2StrBlank(endTime), 1,1, "yyyyMMdd","yyyyMM");
|
if(null!=months && months.size()>0) {
|
for(int i=0; i<months.size();i++) {
|
String month = months.get(i);
|
|
String beginDay = month+"01";
|
//得到当月的最后一天
|
String lastDay = DateParepareUtil.lastDayMonth(month,"yyyyMM","yyyyMMdd");
|
|
List<String> days = DateUtil.getBetweenTwoDateCycleList(beginDay, lastDay, 2,1, "yyyyMMdd","yyyyMMdd");
|
|
|
|
|
|
List<Map> newList = new ArrayList<Map>();
|
for(String str : days) {
|
Map map = new HashMap();
|
|
if(cacheMap.containsKey(str)) {
|
map = cacheMap.get(str);
|
map.put("day", str);
|
map.put("check", 1);
|
} else {
|
map.put("day",str);
|
map.put("check", 2);
|
}
|
|
//是否显示复选框
|
long date = ConvertUtil.obj2Long(str);
|
if(date>=beginTime && date<=endTime) {
|
map.put("showbox", 1);
|
} else {
|
map.put("showbox", 2);
|
}
|
|
//今天之前的复选框不可用
|
long today = DateUtil.getCurrentDate8();
|
if(date>today) {
|
map.put("isUse", 1);
|
} else {
|
map.put("isUse", 2);
|
}
|
|
newList.add(map);
|
}
|
|
Map map = new HashMap();
|
map.put("month", month);
|
map.put("days", newList);
|
result.add(map);
|
}
|
}
|
|
}
|
System.out.println(JsonUtil.list2Json(result));
|
return result;
|
}
|
|
@Override
|
public PageInfo getRemindOrderList(PageInfo pageInfo,Map<String, String> param) {
|
String customerId=param.get("customerId");
|
String subId=param.get("subId");
|
String beginDate=param.get("beginDay");
|
String endDate=param.get("endDay");
|
StringBuilder sql = new StringBuilder();
|
sql.append(" SELECT A.SUB_CUSTOMER_ID SUB_CUS_ID,A.FLOW_ID,B.*,D.ITEM_NAME,A.PLAN_EXECUTION_DATE,A.STATE AS TIMESTATE,A.CUSTOMER_ITEM_ID FROM CI_REMIND_TIMERTASK A LEFT JOIN SC_WORKFLOW_CI_REMIND B ON A.FLOW_ID=B.FLOW_ID ");
|
sql.append(" LEFT JOIN CI_REMIND_CUSTOMER_ITEM C ON A.CUSTOMER_ITEM_ID=C.ID LEFT JOIN CI_REMIND_ITEM D ON C.ITEM_ID=D.ID");
|
sql.append(" WHERE A.STATE != 3 ");
|
|
//SqlParameter paramMap = new SqlParameter();
|
|
|
if(StringUtil.notEmpty(customerId)) {
|
sql.append("AND A.CUSTOMER_ID=:customerId ");
|
param.put("customerId", customerId);
|
}
|
|
|
if(StringUtil.notEmpty(subId)) {
|
sql.append("AND A.SUB_CUSTOMER_ID=:subId ");
|
param.put("subId", subId);
|
}
|
|
|
if(StringUtil.notEmpty(beginDate) && StringUtil.notEmpty(endDate)){
|
sql.append(" AND A.PLAN_EXECUTION_DATE>=:beginDate AND A.PLAN_EXECUTION_DATE<=:endDate");
|
param.put("beginDate", beginDate);
|
param.put("endDate", endDate);
|
}
|
sql.append(" ORDER BY A.PLAN_EXECUTION_DATE DESC");
|
param.put("customerId", customerId);
|
|
PageInfo list=baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), param);
|
|
if(list!=null && list.getDatas().size()>0){
|
for(Map map :list.getDatas()){
|
map.put("TIMESTATE_LABEL", Constants.getmapCI_REMIND_TIMERTASK_STATE_Label(Integer.parseInt(map.get("TIMESTATE").toString())));
|
}
|
}
|
return list;
|
}
|
|
@Override
|
public Integer getRemindOrderCount(Map<String, String> param){
|
String customerId=param.get("customerId");
|
String subId=param.get("subId");
|
String beginDate=param.get("beginDay");
|
String endDate=param.get("endDay");
|
StringBuilder sql = new StringBuilder();
|
sql.append(" SELECT COUNT(A.ID) FROM CI_REMIND_TIMERTASK A LEFT JOIN SC_WORKFLOW_CI_REMIND B ON A.FLOW_ID=B.FLOW_ID ");
|
sql.append(" LEFT JOIN CI_REMIND_CUSTOMER_ITEM C ON A.CUSTOMER_ITEM_ID=C.ID LEFT JOIN CI_REMIND_ITEM D ON C.ITEM_ID=D.ID");
|
sql.append(" WHERE A.STATE != 3 ");
|
|
//SqlParameter paramMap = new SqlParameter();
|
|
|
if(StringUtil.notEmpty(customerId)) {
|
sql.append("AND A.CUSTOMER_ID=:customerId ");
|
param.put("customerId", customerId);
|
}
|
|
if(StringUtil.notEmpty(subId)) {
|
sql.append("AND A.SUB_CUSTOMER_ID=:subId ");
|
param.put("subId", subId);
|
}
|
|
|
if(StringUtil.notEmpty(beginDate) && StringUtil.notEmpty(endDate)){
|
sql.append(" AND A.PLAN_EXECUTION_DATE>=:beginDate AND A.PLAN_EXECUTION_DATE<=:endDate");
|
param.put("beginDate", beginDate);
|
param.put("endDate", endDate);
|
}
|
param.put("customerId", customerId);
|
param.put("subId", subId);
|
param.put("beginDate", beginDate);
|
param.put("endDate", endDate);
|
return baseDao.queryForInteger(sql.toString(),param);
|
}
|
|
@Override
|
public List getSubRemindCiList(Map<String, String> param) {
|
StringBuilder sql =new StringBuilder();
|
if(StringUtil.isBlank(param.get("flowId"))){
|
sql.append("SELECT A.*,B.STATE,B.PROJECT_ITEM_ID FROM cmdb_ci_base A ,CI_REMIND_CILIST B ,CI_REMIND_CUSTOMER_ITEM C");
|
sql.append(" WHERE A.ID=B.CI_ID AND B.PROJECT_ITEM_ID=C.ID AND B.PROJECT_ITEM_ID=:itemId");
|
if(StringUtil.isNotBlank(param.get("subCusId"))){
|
sql.append(" AND A.SUB_CUS_ID=:subCusId");
|
}
|
}else{
|
sql.append(" select a.* from cmdb_ci_base a, sc_workflow_ci_remind_detail b,sc_workflow_ci_remind c ");
|
sql.append(" where a.id = b.ci_id and b.order_id = c.id and c.flow_id = :flowId ");
|
}
|
return baseDao.queryForList(sql.toString(), param);
|
}
|
|
@Override
|
public int queryProItemCount(Map<String, String> param) {
|
String customerId = param.get("customerId");
|
param.put("customerId", customerId);
|
String sql = "SELECT COUNT(A.ID) FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B WHERE A.ITEM_ID = B.ID AND A.USING_STATE = 1 AND A.CUSTOMER_ID = :customerId ORDER BY B.ORDER_NUM ";
|
int count = baseDao.queryForInteger(sql, param);
|
return count;
|
}
|
|
|
@Override
|
public PageInfo queryProItemsData(PageInfo pageInfo,Map<String, String> param) {
|
String customerId = param.get("customerId");
|
String sql = "SELECT A.*,B.ITEM_NAME,B.ITEM_NOTE,B.PRIORITY_LEVEL_NAME,B.BUSINESS_NAME " +
|
" FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B WHERE A.ITEM_ID = B.ID " +
|
" AND A.USING_STATE = 1 AND A.CUSTOMER_ID = :customerId ORDER BY B.ORDER_NUM ";
|
|
param.put("customerId", customerId);
|
PageInfo info = baseDao.queryforSplitPageInfo(pageInfo, sql, param);
|
return info;
|
}
|
|
|
@Override
|
public Map queryItemSubCustomerPlan(String customerId,String itemId,String mon) {
|
//查询该客户下的所有下属单位
|
String sql="SELECT * FROM SC_PARTNER_CUSTOMER_SUB WHERE CUSTOMER_ID=:customerId AND DEL_FLAG=1";
|
List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));
|
|
|
Map currentCustomer = new HashMap();
|
currentCustomer.put("ID", customerId);
|
currentCustomer.put("CUSTOMER_NAME", new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById().getCustomer_name());
|
subList.add(0, currentCustomer);
|
|
String year = DateUtil.format("yyyy", mon);
|
|
String mm = DateUtil.format("MM", mon);
|
String[] time = DateParepareUtil.queryFirstLastDate(year,mm);
|
|
String beginDay = time[0].replaceAll("-", "");
|
//得到当月的最后一天
|
String lastDay = time[1].replaceAll("-", "");
|
|
List<String> days = DateUtil.getBetweenTwoDateCycleList(beginDay, lastDay, 2,1, "yyyyMMdd","yyyyMMdd");
|
|
Map resultMap = new HashMap();
|
resultMap.put("month", mon);
|
resultMap.put("days", days);
|
|
List result = new ArrayList();
|
if(StringUtil.notEmpty(customerId)) {
|
SC_PARTNER_CUSTOMER_INFO customer = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();
|
|
long beginTime = customer.getValid_begin_date();
|
long endTime = customer.getValid_end_date();
|
|
|
Map paramMap = new HashMap();
|
//查询该客户下所有已经生成的计划
|
String selectSql = "SELECT A.*,W.ID ORDER_ID FROM CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B ,SC_WORKFLOW_CI_REMIND W " +
|
" WHERE A.CUSTOMER_ITEM_ID = B.ID AND A.FLOW_ID=W.FLOW_ID " +
|
" AND A.CUSTOMER_ITEM_ID = :projectItemId " +
|
" AND B.CUSTOMER_ID = :customerId AND B.USING_STATE = 1 ";
|
paramMap.put("projectItemId", itemId);
|
paramMap.put("customerId", customerId);
|
|
|
|
selectSql += "AND A.PLAN_EXECUTION_DATE >= :beginTime AND A.PLAN_EXECUTION_DATE <= :endTime ";
|
paramMap.put("beginTime", beginDay);
|
paramMap.put("endTime", lastDay);
|
|
selectSql += " ORDER BY A.PLAN_EXECUTION_DATE ";
|
List<Map> plans = baseDao.queryForList(selectSql,paramMap);
|
|
Map<String,Map> cacheMap = new HashMap<String,Map>();
|
if(null!=plans && plans.size()>0) {
|
for(Map plan : plans) {
|
String subCustomerId = ConvertUtil.obj2StrBlank(plan.get("SUB_CUSTOMER_ID"));
|
String plan_execution_date = ConvertUtil.obj2StrBlank(plan.get("PLAN_EXECUTION_DATE"));
|
cacheMap.put(subCustomerId+"-"+plan_execution_date, plan);
|
}
|
}
|
|
|
if(null!=subList && subList.size()>0) {
|
for(Map cus : subList) {
|
|
|
|
String cusId = ConvertUtil.obj2StrBlank(cus.get("ID"));
|
String cusName = ConvertUtil.obj2StrBlank(cus.get("CUSTOMER_NAME"));
|
|
List<Map> newList = new ArrayList<Map>();
|
for(String str : days) {
|
Map map = new HashMap();
|
|
String unitKey = cusId+"-"+str;
|
if(cacheMap.containsKey(unitKey)) {
|
map = cacheMap.get(unitKey);
|
}
|
newList.add(map);
|
}
|
|
Map map = new HashMap();
|
map.put("cusName", cusName);
|
map.put("msgs", newList);
|
result.add(map);
|
}
|
}
|
|
}
|
resultMap.put("rs", result);
|
|
return resultMap;
|
}
|
|
@Override
|
public String queryZbName(String itemId) {
|
String selectSql = "SELECT B.ITEM_NAME FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B WHERE A.ITEM_ID = B.ID AND A.ID = :itemId ";
|
return baseDao.queryForString(selectSql,new SqlParameter("itemId",itemId));
|
}
|
|
@Override
|
public List queryCustomers(Map<String, String> param) {
|
String customerId = param.get("customerId");
|
//查询该客户下的所有下属单位
|
String sql="SELECT * FROM SC_PARTNER_CUSTOMER_SUB WHERE CUSTOMER_ID=:customerId AND DEL_FLAG=1";
|
List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));
|
|
|
Map currentCustomer = new HashMap();
|
currentCustomer.put("ID", customerId);
|
SC_PARTNER_CUSTOMER_INFO mainCus = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();
|
currentCustomer.put("CUSTOMER_NAME", mainCus.getCustomer_name());
|
currentCustomer.put("CONTACT", mainCus.getContact());
|
currentCustomer.put("PHONE", mainCus.getPhone());
|
|
subList.add(0, currentCustomer);
|
return subList;
|
}
|
|
@Override
|
public Map queryCusItemPlanReport(String customerId,String subCustomerId, String mon) {
|
//查询该客户下的所有指标
|
String sql="SELECT A.*,B.ITEM_NAME,B.ITEM_NOTE,B.PRIORITY_LEVEL_NAME,B.BUSINESS_NAME " +
|
" FROM CI_REMIND_CUSTOMER_ITEM A,CI_REMIND_ITEM B " +
|
" WHERE A.ITEM_ID = B.ID AND A.USING_STATE = 1 AND A.CUSTOMER_ID = :customerId ORDER BY B.ORDER_NUM ";
|
List<Map> subList=baseDao.queryForList(sql, new SqlParameter().addValue("customerId",customerId));
|
|
|
|
String year = DateUtil.format("yyyy", mon);
|
|
String mm = DateUtil.format("MM", mon);
|
String[] time = DateParepareUtil.queryFirstLastDate(year,mm);
|
|
String beginDay = time[0].replaceAll("-", "");
|
//得到当月的最后一天
|
String lastDay = time[1].replaceAll("-", "");
|
|
List<String> days = DateUtil.getBetweenTwoDateCycleList(beginDay, lastDay, 2,1, "yyyyMMdd","yyyyMMdd");
|
|
Map resultMap = new HashMap();
|
resultMap.put("month", mon);
|
resultMap.put("days", days);
|
|
List result = new ArrayList();
|
if(StringUtil.notEmpty(customerId)) {
|
SC_PARTNER_CUSTOMER_INFO project = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();
|
|
long beginTime = project.getValid_begin_date();
|
long endTime = project.getValid_end_date();
|
|
|
Map paramMap = new HashMap();
|
//查询该客户下所有已经生成的计划
|
String selectSql = "SELECT A.*,W.ID ORDER_ID FROM CI_REMIND_TIMERTASK A,CI_REMIND_CUSTOMER_ITEM B,SC_WORKFLOW_CI_REMIND W " +
|
" WHERE A.CUSTOMER_ITEM_ID = B.ID AND A.FLOW_ID=W.FLOW_ID AND B.CUSTOMER_ID = :customerId " +
|
" AND A.SUB_CUSTOMER_ID = :subCustomerId AND B.USING_STATE = 1 ";
|
paramMap.put("customerId", customerId);
|
|
selectSql += "AND A.PLAN_EXECUTION_DATE >= :beginTime AND A.PLAN_EXECUTION_DATE <= :endTime ";
|
paramMap.put("beginTime", beginDay);
|
paramMap.put("endTime", lastDay);
|
paramMap.put("subCustomerId", subCustomerId);
|
|
selectSql += " ORDER BY A.PLAN_EXECUTION_DATE ";
|
List<Map> plans = baseDao.queryForList(selectSql,paramMap);
|
|
Map<String,Map> cacheMap = new HashMap<String,Map>();
|
if(null!=plans && plans.size()>0) {
|
for(Map plan : plans) {
|
String project_item_id = ConvertUtil.obj2StrBlank(plan.get("CUSTOMER_ITEM_ID"));
|
String plan_execution_date = ConvertUtil.obj2StrBlank(plan.get("PLAN_EXECUTION_DATE"));
|
cacheMap.put(project_item_id+"-"+plan_execution_date, plan);
|
}
|
}
|
|
|
if(null!=subList && subList.size()>0) {
|
for(Map zb : subList) {
|
String zbId = ConvertUtil.obj2StrBlank(zb.get("ID"));
|
String zbName = ConvertUtil.obj2StrBlank(zb.get("ITEM_NAME"));
|
|
List<Map> newList = new ArrayList<Map>();
|
for(String str : days) {
|
Map map = new HashMap();
|
|
String unitKey = zbId+"-"+str;
|
if(cacheMap.containsKey(unitKey)) {
|
map = cacheMap.get(unitKey);
|
}
|
newList.add(map);
|
}
|
|
Map map = new HashMap();
|
map.put("zbName", zbName);
|
map.put("msgs", newList);
|
result.add(map);
|
}
|
}
|
|
}
|
resultMap.put("rs", result);
|
|
return resultMap;
|
}
|
|
@Override
|
public String queryNodeId(String flowId,String userId) {
|
String selectSql = "SELECT ID FROM WORKFLOW_NODE WHERE FLOWID=:flowId AND CURRENT_DEALER_ID=:userId AND (FLOWSTATE=1 OR FLOWSTATE =2) ";
|
return baseDao.queryForString(selectSql,new SqlParameter("flowId",flowId).addValue("userId", userId));
|
}
|
|
@Override
|
public PageInfo remindPlanData(PageInfo pageInfo,Map<String, String> param) {
|
String ciId=param.get("ciId");
|
String selectSql = "SELECT C.* FROM CI_REMIND_CILIST A,CI_REMIND_CUSTOMER_ITEM B,CI_REMIND_TIMERTASK C WHERE A.PROJECT_ITEM_ID = B.ID AND B.ID = C.CUSTOMER_ITEM_ID AND A.CI_ID = :ciId AND A.STATE = 1 AND C.STATE = 2 ORDER BY C.PLAN_EXECUTION_DATE DESC ";
|
param.put("ciId", ciId);
|
PageInfo plans=baseDao.queryforSplitPageInfo(pageInfo, selectSql, param);
|
return plans;
|
}
|
|
@Override
|
public int remindPlanCount(Map<String, String> param) {
|
String ciId=param.get("ciId");
|
String selectSql = "SELECT COUNT(C.ID) FROM CI_REMIND_CILIST A,CI_REMIND_CUSTOMER_ITEM B,CI_REMIND_TIMERTASK C WHERE A.PROJECT_ITEM_ID = B.ID AND B.ID = C.CUSTOMER_ITEM_ID AND A.CI_ID = :ciId AND A.STATE = 1 AND C.STATE = 2 ORDER BY C.PLAN_EXECUTION_DATE DESC ";
|
int count = baseDao.queryForInteger(selectSql, new SqlParameter("ciId",ciId));
|
return count;
|
}
|
|
|
|
|
}
|
