package cn.ksource.web.facade.remind;
|
|
import java.util.ArrayList;
|
import java.util.Arrays;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import javax.annotation.Resource;
|
import javax.servlet.http.HttpServletRequest;
|
|
import org.apache.commons.lang.StringUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import cn.ksource.beans.SC_PARTNER_CUSTOMER_INFO;
|
import cn.ksource.beans.SC_PARTNER_CUSTOMER_SUB;
|
import cn.ksource.beans.SC_WORKFLOW_CI_REMIND;
|
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.web.Constants;
|
import cn.ksource.web.entity.WorkFlowSupportEntity;
|
import cn.ksource.web.service.WorkOrderCodeService;
|
import cn.ksource.web.service.workFlowSupport.WorkFlowSupportService;
|
import cn.ksource.web.util.DateParepareUtil;
|
|
@Service
|
@SuppressWarnings({ "rawtypes" })
|
public class RemindFacadeImpl implements RemindFacade {
|
|
@Resource
|
private BaseDao baseDao;
|
@Autowired
|
private WorkOrderCodeService workOrderCodeService;
|
@Autowired
|
private WorkFlowSupportService workFlowSupportService;
|
|
@Override
|
public PageInfo getRemindItemData(PageInfo pageInfo, Map<String, String> params) {
|
Map support = getRmindItemSupport(params);
|
String sql = support.get("sql").toString();
|
return baseDao.queryforSplitPageInfo(pageInfo, sql, params);
|
}
|
|
@Override
|
public Object getRemindItemCount(Map<String, String> params) {
|
Map support = getRmindItemSupport(params);
|
String sql = "select count(*) from ( " + support.get("sql").toString() + " ) t ";
|
return baseDao.queryForInteger(sql, params);
|
}
|
|
private Map getRmindItemSupport(Map<String, String> params) {
|
Map<String, Object> support = new HashMap<String, Object>();
|
StringBuilder sql = new StringBuilder();
|
sql.append(" select a.* ,b.id item_id,b.using_state statu ");
|
sql.append(" from ci_remind_item a,ci_remind_customer_item b ");
|
//sql.append(" where b.item_id=a.id and b.customer_id=:cusId ");
|
sql.append(" where b.item_id=a.id and b.customer_id='-1' ");
|
if (StringUtil.isNotBlank(params.get("itemName"))) {
|
sql.append(" and a.item_name like :itemName ");
|
params.put("itemName", "%" + params.get("itemName") + "%");
|
}
|
if (StringUtil.isNotBlank(params.get("itemType"))) {
|
sql.append(" and a.item_type = :itemType ");
|
}
|
if (StringUtil.isNotBlank(params.get("state"))) {
|
sql.append(" and a.state = :state ");
|
}
|
if (StringUtil.isNotBlank(params.get("fullCateId"))) {
|
String[] arr = params.get("fullCateId").split("-");
|
params.put("cateId", arr[arr.length - 1]);
|
sql.append(" and a.business_id = :cateId ");
|
}
|
sql.append(" order by a.order_num asc ");
|
support.put("sql", sql.toString());
|
support.put("param", params);
|
return support;
|
}
|
|
@Override
|
public void saveRemindItem(Map<String, String> params) {
|
StringBuilder sql = new StringBuilder();
|
String[] cateIds = params.get("full_cate_id").split("-");
|
String[] cateNames = params.get("full_cate_name").split("-");
|
if (cateIds.length == 3) {
|
params.put("business_id", cateIds[2]);
|
params.put("business_name", cateNames[2]);
|
params.put("p_id", cateIds[1]);
|
} else {
|
params.put("business_id", cateIds[1]);
|
params.put("business_name", cateNames[1]);
|
params.put("p_id", cateIds[0]);
|
}
|
|
if (StringUtil.isBlank(params.get("id"))) {// 插入
|
String id = StringUtil.getUUID();
|
params.put("id", id);
|
sql.append(" insert into ci_remind_item ( ");
|
sql.append(" id,item_name,cycle,priority_level_id,priority_level_name,item_note,order_num, ");
|
sql.append(" state,business_id,business_name,item_type,customer_id,p_id,full_cate_id,full_cate_name ");
|
sql.append(" ) values ( ");
|
sql.append(" :id,:item_name,:cycle,:priority_level_id,:priority_level_name,:item_note,:order_num, ");
|
sql.append(" 1,:business_id,:business_name,:item_type,:customer_id,:p_id,:full_cate_id,:full_cate_name ) ");
|
baseDao.execute(sql.toString(), params);
|
sql.setLength(0);
|
params.put("item_id", id);
|
params.put("id", StringUtil.getUUID());
|
sql.append("insert into ci_remind_customer_item (id,customer_id,item_id,using_state) values ");
|
sql.append(" (:id,:customer_id,:item_id,1) ");
|
baseDao.execute(sql.toString(), params);
|
} else {// 编辑
|
sql.append(
|
" update ci_remind_item set item_name=:item_name,cycle=:cycle,priority_level_id=:priority_level_id, ");
|
sql.append(
|
" priority_level_name=:priority_level_name,item_note=:item_note,order_num=:order_num,business_id=:business_id, ");
|
sql.append(
|
" business_name=:business_name,p_id=:p_id,full_cate_id=:full_cate_id,full_cate_name=:full_cate_name ");
|
sql.append(" where id=:id ");
|
baseDao.execute(sql.toString(), params);
|
}
|
|
}
|
|
@Override
|
public Map getRemindItemById(String id) {
|
return baseDao.queryForMap("select * from ci_remind_item where id=:id ", new SqlParameter("id", id));
|
}
|
|
@Override
|
public List<Map> getGelItemList(Map<String, String> params) {
|
StringBuilder sql = new StringBuilder();
|
sql.append(" select a.* from ci_remind_item a where a.state=1 and a.item_type=1 and not exists ");
|
sql.append(" (select item_id from ci_remind_customer_item b where b.item_id=a.id and b.customer_id=:cusId ) ");
|
if (StringUtil.isNotBlank(params.get("itemName"))) {
|
sql.append(" and a.item_name like :itemName ");
|
params.put("itemName", "%" + params.get("itemName") + "%");
|
}
|
if (StringUtil.isNotBlank(params.get("fullCateId"))) {
|
String[] arr = params.get("fullCateId").split("-");
|
params.put("cateId", arr[arr.length - 1]);
|
sql.append(" and a.business_id = :cateId ");
|
}
|
return baseDao.queryForList(sql.toString(), params);
|
}
|
|
@Override
|
public void doSelGelRemindItem(String ids, String cusId) {
|
StringBuilder sql = new StringBuilder();
|
String[] arr = ids.split(",");
|
List<String> list = Arrays.asList(arr);
|
sql.append(" select * from ci_remind_item where id in (:list) ");
|
List<Map> items = baseDao.queryForList(sql.toString(), new SqlParameter("list", list));
|
if (items != null && items.size() > 0) {
|
sql.setLength(0);
|
sql.append("insert into ci_remind_customer_item (id,customer_id,item_id,using_state) values ");
|
sql.append(" (:id,:cusId,:item_id,1) ");
|
List<SqlParameter> pList = new ArrayList<SqlParameter>();
|
for (Map item : items) {
|
SqlParameter p = new SqlParameter();
|
p.putAll(item);
|
p.put("id", StringUtil.getUUID());
|
p.put("cusId", cusId);
|
p.put("item_id", item.get("id"));
|
pList.add(p);
|
}
|
baseDao.executeBatch(sql.toString(), pList);
|
|
}
|
|
}
|
|
/**
|
* 跳转到给客户制定计划页面
|
*/
|
@Override
|
public Map queryCustomerDetail(String customerId) {
|
String selectSql = "SELECT B.ID, B.CUSTOMER_NAME,B.CONTACT,B.PHONE,C.CUSTOMER_ID ,C.SUB_CUSTOMER_ID "
|
+ " FROM SC_PARTNER_CUSTOMER_INFO B LEFT JOIN CI_REMIND_CUSTOMER_ITEM_CYCLE C ON B.ID=C.CUSTOMER_ID "
|
+ " WHERE B.ID = :customerId ";
|
Map project = baseDao.queryForMap(selectSql, new SqlParameter("customerId", customerId));
|
return project;
|
}
|
|
/**
|
* 查询子客户
|
*
|
* @param customerId
|
* @return
|
*/
|
@Override
|
public List querySubList(String customerId) {
|
Map paramMap = new HashMap();
|
paramMap.put("customerId", customerId);
|
// 查询当前客户的信息
|
String selectSql = "SELECT ID,CUSTOMER_NAME FROM SC_PARTNER_CUSTOMER_INFO WHERE ID = :customerId";
|
Map customer = baseDao.queryForMap(selectSql, paramMap);
|
if (null != customer && customer.size() > 0) {
|
// 查询下级客户
|
String selectSubSql = "SELECT A.*,B.CONTACTS_NAME,B.CONTACTS_TEL "
|
+ " FROM SC_PARTNER_CUSTOMER_SUB A LEFT JOIN CI_REMIND_CUSTOMER_ITEM_CYCLE B "
|
+ " ON B.SUB_CUSTOMER_ID=A.ID WHERE A.CUSTOMER_ID = :customerId "
|
+ " AND A.DEL_FLAG = 1 GROUP BY A.ID ORDER BY A.MY_LEVEL ";
|
List<Map> subCus = baseDao.queryForList(selectSubSql, paramMap);
|
|
return subCus;
|
}
|
return null;
|
}
|
|
@Override
|
public Map queryPlanCount(String itemId, String customerId) {
|
String selectSql = "SELECT CUSTOMER_ID,SUB_CUSTOMER_ID,COUNT(ID) AS NUM FROM CI_REMIND_TIMERTASK WHERE CUSTOMER_ID = :customerId AND CUSTOMER_ITEM_ID = :itemId GROUP BY CUSTOMER_ID,SUB_CUSTOMER_ID";
|
Map paramMap = new HashMap();
|
paramMap.put("itemId", itemId);
|
paramMap.put("customerId", customerId);
|
List<Map> plans = baseDao.queryForList(selectSql, paramMap);
|
Map resultMap = new HashMap();
|
|
if (null != plans && plans.size() > 0) {
|
for (Map plan : plans) {
|
String customer = ConvertUtil.obj2StrBlank(plan.get("CUSTOMER_ID"));
|
String subCustomerId = ConvertUtil.obj2StrBlank(plan.get("SUB_CUSTOMER_ID"));
|
String num = ConvertUtil.obj2StrBlank(plan.get("NUM"));
|
resultMap.put(customer + "-" + subCustomerId, num);
|
}
|
}
|
|
String selectSql2 = "SELECT CUSTOMER_ID,SUB_CUSTOMER_ID,STATE,COUNT(ID) AS NUM FROM CI_REMIND_TIMERTASK WHERE CUSTOMER_ID = :customerId AND STATE = 2 AND CUSTOMER_ITEM_ID = :itemId GROUP BY CUSTOMER_ID,SUB_CUSTOMER_ID,STATE";
|
List<Map> zxPlans = baseDao.queryForList(selectSql2, paramMap);
|
if (null != zxPlans && zxPlans.size() > 0) {
|
for (Map plan : zxPlans) {
|
String customer = ConvertUtil.obj2StrBlank(plan.get("CUSTOMER_ID"));
|
String subCustomerId = ConvertUtil.obj2StrBlank(plan.get("SUB_CUSTOMER_ID"));
|
String num = ConvertUtil.obj2StrBlank(plan.get("NUM"));
|
resultMap.put(customer + "-" + subCustomerId + "2", num);
|
}
|
}
|
return resultMap;
|
}
|
|
@Override
|
public Map queryRemindItemCycle(String itemId, String customerId, String subId) {
|
String selectSql = new String();
|
Map paramMap = new HashMap();
|
paramMap.put("itemId", itemId);
|
paramMap.put("customerId", customerId);
|
paramMap.put("subId", subId);
|
if(StringUtil.isBlank(subId)){
|
paramMap.put("subId", customerId);
|
}
|
selectSql = "SELECT * FROM CI_REMIND_CUSTOMER_ITEM_CYCLE WHERE PROJECT_ITEM_ID = :itemId AND CUSTOMER_ID = :customerId AND SUB_CUSTOMER_ID = :subId ";
|
Map cycle = baseDao.queryForMap(selectSql, paramMap);
|
return cycle;
|
}
|
|
/**
|
* 删除未执行的例行维护计划表
|
*/
|
private void deleteRemindTask(String customerItemId, String customerId, String subCustomerId) {
|
// long today = DateUtil.getCurrentDate8();
|
String deleteSql = "DELETE FROM CI_REMIND_TIMERTASK WHERE PLAN_EXECUTION_DATE > :today AND STATE = :state AND CUSTOMER_ITEM_ID = :customerItemId AND CUSTOMER_ID = :customerId";
|
Map paramMap = new HashMap();
|
paramMap.put("customerId", customerId);
|
if (StringUtil.notEmpty(subCustomerId)) {
|
deleteSql += " AND SUB_CUSTOMER_ID = :subCustomerId ";
|
paramMap.put("subCustomerId", subCustomerId);
|
} else {
|
deleteSql += " AND SUB_CUSTOMER_ID = :customerId ";
|
}
|
|
paramMap.put("today", DateUtil.getCurrentDate8());
|
paramMap.put("state", Constants.CI_REMIND_TIMERTASK_STATE_WZX);
|
paramMap.put("customerItemId", customerItemId);
|
// paramMap.put("today", today);
|
baseDao.execute(deleteSql, paramMap);
|
}
|
|
/**
|
* 生成例行维护计划表
|
*
|
* @param projectItemId
|
*/
|
private void createRemindTask(String id, String projectItemId, String customerId, String subCustomerId) {
|
// 查询项目
|
|
String selectSql = "SELECT A.* ,C.VALID_END_DATE FROM CI_REMIND_CUSTOMER_ITEM_CYCLE A,SC_PARTNER_CUSTOMER_INFO C"
|
+ " WHERE A.CUSTOMER_ID = C.ID AND A.ID=:id AND C.CUSTOMER_STATE=1 AND C.VALID_END_DATE >= :today AND C.VALID_BEGIN_DATE <= :today ";
|
String cid = customerId;
|
|
Map item = baseDao.queryForMap(selectSql,new SqlParameter("id", id).addValue("today", DateUtil.getCurrentDate8()).addValue("cid", cid));
|
if (null != item && item.size() > 0) {
|
String leix = ConvertUtil.obj2StrBlank(item.get("LEIX"));
|
String zhouqi = ConvertUtil.obj2StrBlank(item.get("ZHOUQI"));
|
|
String endTime = ConvertUtil.obj2StrBlank(item.get("VALID_END_DATE"));
|
|
String today = DateUtil.getToday("yyyyMMdd");
|
|
Map paramMap = new HashMap();
|
paramMap.put("projectItemId", projectItemId);
|
paramMap.put("state", Constants.CI_REMIND_TIMERTASK_STATE_YZX);
|
paramMap.put("customerId", customerId);
|
// 查询已经执行过的日期，生成新的提醒表时，去掉已经执行过的日期
|
String zxSql = "SELECT * FROM CI_REMIND_TIMERTASK WHERE CUSTOMER_ITEM_ID = :projectItemId AND STATE = :state AND CUSTOMER_ID = :customerId ";
|
zxSql += " AND SUB_CUSTOMER_ID = :subCustomerId ";
|
if (StringUtil.notEmpty(subCustomerId)) {
|
paramMap.put("subCustomerId", subCustomerId);
|
} else {
|
paramMap.put("subCustomerId", customerId);
|
}
|
List<Map> zxList = baseDao.queryForList(zxSql, paramMap);
|
Map zxCache = new HashMap();
|
if (null != zxList && zxList.size() > 0) {
|
for (Map zx : zxList) {
|
String day = ConvertUtil.obj2StrBlank(zx.get("PLAN_EXECUTION_DATE"));
|
zxCache.put(day, zx);
|
}
|
}
|
|
// 生成智能提醒时间表
|
String insertSql = "INSERT INTO CI_REMIND_TIMERTASK(ID,CUSTOMER_ITEM_ID,STATE,PLAN_EXECUTION_DATE,CUSTOMER_ID,SUB_CUSTOMER_ID) VALUES (:id,:project_item_id,1,:plan_execution_date,:customerId,:subCustomerId)";
|
if (leix.equals("1")) {
|
String beginExecDate = ConvertUtil.obj2StrBlank(item.get("BEGIN_EXEC_DATE"));
|
|
List<SqlParameter> paramList = new ArrayList<SqlParameter>();
|
List<String> dates = DateUtil.getBetweenTwoDateCycleList(beginExecDate, endTime, 2,
|
ConvertUtil.obj2Int(zhouqi), "yyyyMMdd", "yyyyMMdd");
|
if (null != dates && dates.size() > 0) {
|
Map param = new HashMap();
|
param.put("project_item_id", projectItemId);
|
param.put("customerId", customerId);
|
if (StringUtil.notEmpty(subCustomerId)) {
|
param.put("subCustomerId", subCustomerId);
|
} else {
|
param.put("subCustomerId", customerId);
|
}
|
for (String str : dates) {
|
if (!zxCache.containsKey(str)) {
|
SqlParameter sqlParameter = new SqlParameter();
|
sqlParameter.addValue("id", StringUtil.getUUID());
|
|
sqlParameter.addValue("plan_execution_date", str);
|
sqlParameter.putAll(param);
|
paramList.add(sqlParameter);
|
}
|
}
|
baseDao.executeBatch(insertSql, paramList);
|
}
|
}
|
}
|
}
|
|
/**
|
* 更新例行维护的执行周期
|
*/
|
@Override
|
public boolean updateRemindCycle(HttpServletRequest request) {
|
|
String id = request.getParameter("id");
|
String leix = request.getParameter("leix");
|
String zhouqi = request.getParameter("zhouqi");
|
String execDate = request.getParameter("execDate");
|
String beginExecDate = request.getParameter("beginExecDate");
|
|
String project_item_id = request.getParameter("project_item_id");
|
|
String customerId = request.getParameter("customerId");
|
|
String subId = request.getParameter("subId");
|
String contactsName = request.getParameter("contactsName");
|
|
String contactsTel = request.getParameter("contactsTel");
|
|
if (StringUtil.notEmpty(id)) {
|
String updateSql = "UPDATE CI_REMIND_CUSTOMER_ITEM_CYCLE SET LEIX = :leix,ZHOUQI = :zhouqi,BEGIN_EXEC_DATE = :beginExecDate,CONTACTS_NAME=:contactsName,CONTACTS_TEL=:contactsTel WHERE ID = :id ";
|
Map paramMap = new HashMap();
|
paramMap.put("leix", leix);
|
if (leix.equals("1")) {
|
paramMap.put("zhouqi", zhouqi);
|
paramMap.put("beginExecDate", beginExecDate);
|
} else if (leix.equals("2")) {
|
paramMap.put("zhouqi", null);
|
paramMap.put("beginExecDate", null);
|
}
|
paramMap.put("id", id);
|
paramMap.put("contactsName", contactsName);
|
paramMap.put("contactsTel", contactsTel);
|
baseDao.execute(updateSql, paramMap);
|
} else {
|
String insertSql = "INSERT INTO CI_REMIND_CUSTOMER_ITEM_CYCLE(ID,PROJECT_ITEM_ID,LEIX,ZHOUQI,BEGIN_EXEC_DATE,CUSTOMER_ID,SUB_CUSTOMER_ID,CONTACTS_NAME,CONTACTS_TEL) VALUES (:id,:project_item_id,:leix,:zhouqi,:begin_exec_date,:customer_id,:sub_customer_id,:contactsName,:contactsTel)";
|
Map paramMap = new HashMap();
|
id = StringUtil.getUUID();
|
paramMap.put("id", id);
|
paramMap.put("project_item_id", project_item_id);
|
paramMap.put("leix", leix);
|
if (leix.equals("1")) {
|
paramMap.put("zhouqi", zhouqi);
|
paramMap.put("begin_exec_date", beginExecDate);
|
} else if (leix.equals("2")) {
|
paramMap.put("zhouqi", null);
|
paramMap.put("begin_exec_date", null);
|
}
|
paramMap.put("customer_id", customerId);
|
if (StringUtil.notEmpty(subId)) {
|
paramMap.put("sub_customer_id", subId);
|
} else {
|
paramMap.put("sub_customer_id", customerId);
|
}
|
paramMap.put("contactsName", contactsName);
|
paramMap.put("contactsTel", contactsTel);
|
baseDao.execute(insertSql, paramMap);
|
}
|
|
// 删除未执行的例行维护计划
|
deleteRemindTask(project_item_id, customerId, subId);
|
|
// 新增新的计划
|
createRemindTask(id, project_item_id, customerId, subId);
|
|
return true;
|
}
|
|
@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 CUSTOMER_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 * FROM CI_REMIND_TIMERTASK WHERE CUSTOMER_ITEM_ID = :customerItemId AND CUSTOMER_ID = :customerId ";
|
paramMap.put("customerId", customerId);
|
paramMap.put("customerItemId", customerItemId);
|
selectSql += " AND SUB_CUSTOMER_ID = :subId ";
|
if (StringUtil.notEmpty(subCustomerId)) {
|
paramMap.put("subId", subCustomerId);
|
} else {
|
paramMap.put("subId", customerId);
|
}
|
|
selectSql += " ORDER BY 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 boolean saveRemindItemPlan(Map<String, String> param, String[] days) {
|
String customerItemId = param.get("customerItemId");
|
String customerId = param.get("customerId");
|
String subId = param.get("subId");
|
System.out.println(days);
|
|
// 删除未执行的例行维护计划表
|
deleteRemindTask(customerItemId, customerId, subId);
|
|
// 通过传进来的日期，生成新的执行计划表
|
if (null != days && days.length > 0) {
|
String insertSql = "INSERT INTO CI_REMIND_TIMERTASK(ID,CUSTOMER_ITEM_ID,STATE,PLAN_EXECUTION_DATE,CUSTOMER_ID,SUB_CUSTOMER_ID) VALUES (:id,:customer_item_id,1,:plan_execution_date,:customer_id,:sub_customer_id)";
|
List<SqlParameter> paramList = new ArrayList<SqlParameter>();
|
param.put("customer_id", customerId);
|
param.put("customer_item_id", customerItemId);
|
if (StringUtil.isNotBlank(subId)) {
|
param.put("sub_customer_id", subId);
|
} else {
|
param.put("sub_customer_id", customerId);
|
}
|
for (String day : days) {
|
SqlParameter sqlParameter = new SqlParameter();
|
sqlParameter.put("id", StringUtil.getUUID());
|
sqlParameter.put("plan_execution_date", day);
|
sqlParameter.putAll(param);
|
paramList.add(sqlParameter);
|
}
|
baseDao.executeBatch(insertSql, paramList);
|
}
|
|
return true;
|
}
|
|
@Override
|
public List getSubRemindCiList(Map<String, String> param) {
|
String itemId = param.get("itemId");
|
String subId = param.get("subId");
|
String customerId = param.get("customerId");
|
StringBuilder sql = new StringBuilder();
|
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 AND B.STATE=1 AND A.STATE=1");
|
// SqlParameter params=new SqlParameter();
|
// if(StringUtil.notEmpty(subId)){
|
sql.append(" AND A.SUB_CUS_ID=:subId");
|
// }else{
|
// sql.append(" AND A.CUS_ID=:customerId");
|
// }
|
param.put("itemId", itemId);
|
param.put("subId", subId);
|
param.put("customerId", customerId);
|
return baseDao.queryForList(sql.toString(), param);
|
}
|
|
@Override
|
public PageInfo getSubCheckCiList(PageInfo pageInfo, Map<String, String> param) {
|
String itemId = param.get("itemId");
|
String customerId = param.get("customerId");
|
String subId = param.get("subId");
|
if (!StringUtil.notEmpty(subId)) {
|
subId = customerId;
|
}
|
String ciName = param.get("ciName");
|
String cateId = param.get("cateId");
|
String categoryId = param.get("categoryId");
|
String code = param.get("code");
|
StringBuilder sql = new StringBuilder();
|
sql.append("SELECT * FROM cmdb_ci_base A ");
|
sql.append(" WHERE A.SUB_CUS_ID=:subId AND A.STATE=1 AND A.ID");
|
sql.append(" NOT IN(SELECT A.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.notEmpty(ciName)) {
|
sql.append(" AND A.CINAME LIKE :ciName");
|
}
|
if(StringUtil.notEmpty(code)){
|
sql.append(" AND A.SEARCHCODE LIKE :code");
|
}
|
// if(StringUtil.notEmpty(cateId)){
|
// sql.append(" AND A.LV3_ID = :cateId");
|
// }
|
if (StringUtil.notEmpty(subId)) {
|
sql.append(" AND A.SUB_CUS_ID=:subId");
|
} else {
|
sql.append(" AND A.CUS_ID=:customerId");
|
}
|
if (StringUtil.notEmpty(categoryId)) {
|
sql.append(" AND ( A.LV3_ID=:categoryId OR A.LV2_ID=:categoryId )");
|
}
|
sql.append(" GROUP BY A.ID");
|
// SqlParameter param=new SqlParameter();
|
|
param.put("itemId", itemId);
|
param.put("subId", subId);
|
param.put("customerId", customerId);
|
param.put("ciName", "%" + ciName + "%");
|
param.put("code", "%" + code + "%");
|
param.put("cateId", cateId);
|
|
param.put("itemId", itemId);
|
param.put("subId", subId);
|
param.put("customerId", customerId);
|
param.put("ciName", "%" + ciName + "%");
|
param.put("categoryId", categoryId);
|
|
pageInfo = baseDao.queryforSplitPageInfo(pageInfo, sql.toString(), param);
|
|
return pageInfo;
|
}
|
|
@Override
|
public Integer getSubCheckCiCount(Map<String, String> param) {
|
String itemId = param.get("itemId");
|
String subId = param.get("subId");
|
String ciName = param.get("ciName");
|
String code = param.get("code");
|
String customerId = param.get("customerId");
|
String categoryId = param.get("categoryId");
|
StringBuilder sql = new StringBuilder();
|
sql.append("SELECT count(*) FROM cmdb_ci_base A ");
|
sql.append(" WHERE A.SUB_CUS_ID=:subId AND A.STATE=1 AND A.ID");
|
sql.append(" NOT IN(SELECT A.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.notEmpty(ciName)) {
|
sql.append(" AND A.CINAME LIKE :ciName");
|
}
|
if(StringUtil.notEmpty(code)){
|
sql.append(" AND A.SEARCHCODE LIKE :code");
|
}
|
if (StringUtil.notEmpty(subId)) {
|
sql.append(" AND A.SUB_CUS_ID=:subId");
|
} else {
|
sql.append(" AND A.CUS_ID=:customerId");
|
}
|
if (StringUtil.notEmpty(categoryId)) {
|
sql.append(" AND A.LV3_ID=:categoryId");
|
}
|
param.put("itemId", itemId);
|
param.put("subId", subId);
|
param.put("customerId", customerId);
|
param.put("ciName", "%" + ciName + "%");
|
param.put("code", "%" + code + "%");
|
param.put("categoryId", categoryId);
|
return baseDao.queryForInteger(sql.toString(), param);
|
}
|
|
@Override
|
public String saveSubCi(Map<String, String> param) {
|
String itemId = param.get("itemId");
|
String item = param.get("item");
|
if (StringUtil.notEmpty(itemId) && StringUtil.notEmpty(item)) {
|
String[] items = item.split(",");
|
String insertSql = "INSERT INTO CI_REMIND_CILIST(ID,PROJECT_ITEM_ID,CI_ID,STATE) VALUES (:id,:itemId,:item,1)";
|
List<SqlParameter> paramList = new ArrayList<SqlParameter>();
|
for (String str : items) {
|
if (StringUtil.notEmpty(str)) {
|
SqlParameter sqlParameter = new SqlParameter();
|
sqlParameter.put("id", StringUtil.getUUID());
|
sqlParameter.put("itemId", itemId);
|
sqlParameter.put("item", str);
|
paramList.add(sqlParameter);
|
}
|
}
|
baseDao.executeBatch(insertSql, paramList);
|
return "1";
|
}
|
return "2";
|
}
|
|
/**
|
* 禁用/启用设备
|
*/
|
@Override
|
public void deleteSubRemindCi(Map<String, String> param) {
|
String ciId = param.get("ciId");
|
String type = param.get("type");
|
String itemId = param.get("itemId");
|
String sql = "DELETE FROM CI_REMIND_CILIST WHERE CI_ID=:ciId AND PROJECT_ITEM_ID=:itemId";
|
baseDao.execute(sql,
|
new SqlParameter().addValue("ciId", ciId).addValue("type", type).addValue("itemId", itemId));
|
|
}
|
|
/**
|
* 定时生成例行维护工单
|
*/
|
@Override
|
public boolean saveRemindOrder() {
|
|
long today = DateUtil.getCurrentDate8();
|
long nextWeek = DateUtil.getDateAdd(today, 7, 8);
|
// 查询一周内需要生成的工单
|
String selectSql = "SELECT C.ITEM_NAME,C.ITEM_NOTE,A.*,B.ID AS CUSTOMER_ITEM_NUM,B.ITEM_ID,C.BUSINESS_ID "
|
+ " 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 B.USING_STATE = 1 AND A.STATE = :state "
|
+ " AND A.PLAN_EXECUTION_DATE >=:today AND A.PLAN_EXECUTION_DATE<:nextWeek ";
|
Map paramMap = new HashMap();
|
paramMap.put("state", Constants.CI_REMIND_TIMERTASK_STATE_WZX);
|
paramMap.put("today", today);
|
paramMap.put("nextWeek", nextWeek);
|
List<Map> tasks = baseDao.queryForList(selectSql, paramMap);
|
|
long createTime = DateUtil.getCurrentDate14();
|
// 循环启动流程
|
if (null != tasks && tasks.size() > 0) {
|
List<SqlParameter> backParam = new ArrayList<SqlParameter>();
|
for (Map task : tasks) {
|
String customerId = ConvertUtil.obj2StrBlank(task.get("CUSTOMER_ID"));
|
if (StringUtil.notEmpty(customerId)) {
|
String remind_id = ConvertUtil.obj2StrBlank(task.get("ITEM_ID"));
|
|
String subCustomerId = ConvertUtil.obj2StrBlank(task.get("SUB_CUSTOMER_ID"));
|
|
SC_PARTNER_CUSTOMER_INFO customer = new SC_PARTNER_CUSTOMER_INFO(customerId).getInstanceById();
|
String customerName = customer.getCustomer_name();
|
|
String insertSql = "INSERT INTO SC_WORKFLOW_CI_REMIND(ID,ORDER_CODE,NAME,CUSTOMER_ID,CUSTOMER_NAME,CREATE_TIME,STATE,REMIND_ID,SUB_CUSTOMER_ID,SUB_CUSTOMER_NAME,CONTACTS_NAME,CONTACTS_TEL,SERVICE_CONTENT) "
|
+ "VALUES (:id,:order_code,:name,:customer_id,:customer_name,:create_time,1,:remind_id,:sub_customer_id,:sub_customer_name,:contacts_name,:contacts_tel,:item_note)";
|
Map param = new HashMap();
|
String orderId = StringUtil.getUUID();
|
param.put("id", orderId);
|
String orderCode = workOrderCodeService.getCiRemindOrderCode();
|
param.put("order_code", orderCode);
|
param.put("customer_id", customerId);
|
param.put("customer_name", customerName);
|
param.put("create_time", createTime);
|
|
param.put("remind_id", remind_id);
|
param.put("name", "例行维护-" + ConvertUtil.obj2StrBlank(task.get("ITEM_NAME")));
|
param.put("item_note", ConvertUtil.obj2StrBlank(task.get("ITEM_NOTE")));
|
|
if (StringUtil.notEmpty(subCustomerId)) {
|
param.put("sub_customer_id", subCustomerId);
|
// 如果客户编号与所属单位编号一致，说明为客户本身，修改人：杨凯
|
if (StringUtils.equalsIgnoreCase(customerId, subCustomerId)) {
|
param.put("sub_customer_name",
|
new SC_PARTNER_CUSTOMER_INFO(subCustomerId).getInstanceById().getCustomer_name());
|
} else {
|
param.put("sub_customer_name",
|
new SC_PARTNER_CUSTOMER_SUB(subCustomerId).getInstanceById().getCustomer_name());
|
}
|
}
|
|
String sql = "SELECT * FROM CI_REMIND_CUSTOMER_ITEM_CYCLE WHERE PROJECT_ITEM_ID=:customer_item_id AND SUB_CUSTOMER_ID=:subId";
|
// 获取周期联系人/联系方式
|
Map cycle = baseDao.queryForMap(sql,
|
new SqlParameter().addValue("customer_item_id", task.get("CUSTOMER_ITEM_NUM"))
|
.addValue("subId", subCustomerId));
|
param.put("contacts_name", cycle.get("CONTACTS_NAME"));
|
param.put("contacts_tel", cycle.get("CONTACTS_TEL"));
|
baseDao.execute(insertSql, param);
|
|
Map pm = new HashMap();
|
// 查询该维护项对应客户指定的设备
|
String ciSql = "SELECT A.* FROM CI_REMIND_CILIST A,CMDB_CI_BASE B WHERE A.CI_ID = B.ID AND A.STATE = 1 AND A.PROJECT_ITEM_ID = :customerItemId AND B.CUS_ID = :customerId ";
|
ciSql += " AND B.SUB_CUS_ID = :subCustomerId ";
|
if (StringUtil.isBlank(subCustomerId)) {
|
pm.put("subCustomerId", customerId);
|
} else {
|
pm.put("subCustomerId", subCustomerId);
|
}
|
|
pm.put("customerItemId", task.get("CUSTOMER_ITEM_ID"));
|
pm.put("customerId", customerId);
|
List<Map> devices = baseDao.queryForList(ciSql, pm);
|
|
if (null != devices && devices.size() > 0) {
|
String insertDeviceSql = "INSERT INTO SC_WORKFLOW_CI_REMIND_DETAIL(ID,ORDER_ID,CI_ID,DEAL_STATE) VALUES (:id,:order_id,:ci_id,3)";
|
List<SqlParameter> deviceParam = new ArrayList<SqlParameter>();
|
for (Map device : devices) {
|
SqlParameter sqlParameter = new SqlParameter();
|
sqlParameter.put("id", StringUtil.getUUID());
|
sqlParameter.put("order_id", orderId);
|
sqlParameter.put("ci_id", device.get("CI_ID"));
|
deviceParam.add(sqlParameter);
|
}
|
baseDao.executeBatch(insertDeviceSql, deviceParam);
|
}
|
|
// ====================================
|
// 启动流程
|
startRemindFlow(orderId, customerId);
|
SC_WORKFLOW_CI_REMIND remind = new SC_WORKFLOW_CI_REMIND(orderId).getInstanceById();
|
|
// ===================================
|
|
// 回填执行计划信息
|
String taskId = ConvertUtil.obj2StrBlank(task.get("ID"));
|
|
SqlParameter sqlParameter = new SqlParameter();
|
sqlParameter.put("id", taskId);
|
sqlParameter.put("state", Constants.CI_REMIND_TIMERTASK_STATE_YZX);
|
|
sqlParameter.put("create_time", createTime);
|
sqlParameter.put("flow_id", remind.getFlow_id());
|
backParam.add(sqlParameter);
|
}
|
}
|
|
if (backParam.size() > 0) {
|
String updateSql = "UPDATE CI_REMIND_TIMERTASK SET STATE = :state,CREATE_TIME = :create_time,FLOW_ID = :flow_id WHERE ID = :id";
|
baseDao.executeBatch(updateSql, backParam);
|
}
|
}
|
|
return true;
|
}
|
|
private SysInfoMsg startRemindFlow(String orderId, String customerId) {
|
// 启动流程
|
WorkFlowSupportEntity support = new WorkFlowSupportEntity();
|
support.setOrderId(orderId);
|
support.setNextNodeTemplateId(Constants.REMIND_DISPATCH);
|
support.setWorkFlowType(Constants.WORKFLOW_BASE_BUSINESS_TYPE_CI_REMIND);
|
|
String sql = "SELECT YWJL_ID USER_ID,YWJL_NAME USER_NAME,1 AS IS_ADMIN FROM SC_PARTNER_CUSTOMER_INFO WHERE ID=:customerId ";
|
|
List<Map> list = new ArrayList<Map>();
|
Map map = baseDao.queryForMap(sql, new SqlParameter("customerId", customerId));
|
|
list.add(map);
|
support.setNextUserList(list);
|
SysInfoMsg msg = workFlowSupportService.doOrderFlow(support);
|
return msg;
|
}
|
|
@Override
|
public PageInfo getCiRemindOrderData(PageInfo pageInfo, Map<String, String> params) {
|
Map support = geCiRemindOrderSupport(params);
|
String sql = support.get("sql").toString();
|
return baseDao.queryforSplitPageInfo(pageInfo, sql, params);
|
}
|
|
@Override
|
public Integer getCiRemindOrderCount(Map<String, String> params) {
|
Map support = geCiRemindOrderSupport(params);
|
String sql = "select count(*) from ( " + support.get("sql").toString() + " ) t ";
|
return baseDao.queryForInteger(sql, params);
|
}
|
|
private Map geCiRemindOrderSupport(Map<String, String> params) {
|
Map<String, Object> support = new HashMap<String, Object>();
|
StringBuilder sql = new StringBuilder();
|
sql.append(" SELECT A.*,B.ORDER_CODE,B.NAME,B.STATE,B.CUSTOMER_NAME,B.CREATE_TIME,B.ID AS BUSINESS_ID ");
|
sql.append(" FROM SC_WORKFLOW_CI_REMIND_DETAIL A,SC_WORKFLOW_CI_REMIND B WHERE A.ORDER_ID = B.ID ");
|
sql.append(" AND A.CI_ID = :id ORDER BY START_TIME DESC ");
|
support.put("sql", sql.toString());
|
support.put("param", params);
|
return support;
|
}
|
|
@Override
|
public void delRemindItem(Map params) {
|
String sql = "update ci_remind_customer_item set using_state = :statu where id=:id ";
|
baseDao.execute(sql, params);
|
}
|
|
}
|
