package net.joystart.taskagent.controller;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.SignatureException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.Callable;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.transaction.Transactional;
import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang3.StringUtils;
import org.json.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.annotation.Scope;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.alibaba.fastjson.JSON;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.reflect.TypeToken;
import net.joystart.City.entity.ServiceCity;
import net.joystart.City.service.ICityService;
import net.joystart.baojia.sign.ZCloudSignConfig;
import net.joystart.carManager.entity.CarManager;
import net.joystart.carManager.service.ICarManagerLogService;
import net.joystart.carManager.service.ICarManagerService;
import net.joystart.common.controller.BaseController;
import net.joystart.common.efence.EfenceBaseType;
import net.joystart.common.efence.EfenceBaseType.EfenceState;
import net.joystart.common.efence.EfenceBuilder;
import net.joystart.common.util.ConstantUtil;
import net.joystart.common.util.HttpRequestUtil;
import net.joystart.common.util.JSONProcesser;
import net.joystart.common.util.MessageResult;
import net.joystart.common.util.PostMsgHttpContent;
import net.joystart.common.util.StringUtil;
import net.joystart.common.util.VehicleControlUtil;
import net.joystart.common.util.baiDu.BaiDuAPIUtil;
import net.joystart.common.util.baiDu.BaiDuAPIUtil.Position;
import net.joystart.common.util.date.UtilTimeFormatter;
import net.joystart.common.util.log.Log4jTask;
import net.joystart.common.util.security.EncryptionUtil;
import net.joystart.common.util.tencent.TengXunAPIUtil;
import net.joystart.customer.entity.Customer;
import net.joystart.customer.entity.MessageTemplate;
import net.joystart.customer.service.ICustomerService;
import net.joystart.customer.service.IMessageTemplateService;
import net.joystart.data.DataBaseUtil;
import net.joystart.device.entity.QueryResult;
import net.joystart.device.service.IVehicleDevice;
import net.joystart.device.service.impl.VehicleDevice;
import net.joystart.fault.service.IFaultReportService;
import net.joystart.mapCoordinates.entity.ReturnForInterface;
import net.joystart.order.controller.OrderController;
import net.joystart.order.entity.DrivingTrack;
import net.joystart.order.entity.InstantOrder;
import net.joystart.order.entity.Order;
import net.joystart.order.service.IOrderService;
import net.joystart.task.vehicleTask.entity.TaskInfo;
import net.joystart.taskagent.controller.entity.TaskToken;
import net.joystart.vehicle.dao.VehicleMapper;
import net.joystart.vehicle.entity.CarState;
import net.joystart.vehicle.entity.Parkinglot;
import net.joystart.vehicle.entity.Vehicle;
import net.joystart.vehicle.entity.VehicleSite;
import net.joystart.vehicle.enums.VehicleStatus;
import net.joystart.vehicle.service.IOperationService;
import net.joystart.vehicle.service.IParkinglotService;
import net.joystart.vehicle.service.IVehicleService;
import net.joystart.vehicle.service.impl.VehicleLock;
import net.joystart.vehicleInterface.controller.VehicleUnLock;
import net.joystart.vehicleInterface.enums.TaskType;
import net.joystart.vehicleInterface.service.IVehicleUnLockService;
import net.joystart.vehicleTask.service.IVehicleTaskService;
import net.joystart.virtualData.AutoAddVirtualData;
/**
* 第三方任务代理
*
* @author lidc@bagechuxing.cn
* @create 2017/07/19
*/
@Controller
@Scope("prototype")
@RequestMapping("/agent")
public class AgentController extends BaseController {
private int AGENT_COMPANY = 1;
private String AGENT_COMPANY_NAME = "e代驾";
private final int EXPIRES_IN = 3600;
@Resource
IVehicleService vehicleService;
@Resource
IVehicleUnLockService vehicleUnLockService;
@Resource
ICustomerService customerService;
@Resource
ICarManagerService carManagerService;
@Resource
ICarManagerLogService carManagerLogService;
@Resource
private IFaultReportService faultReportService;
@Resource
private IMessageTemplateService messageTemplateService;
@Resource
AutoAddVirtualData autoAddVirtualData;
@Resource
ICityService cityService;
@Resource
IVehicleTaskService vehicleTaskService;
@Resource
IParkinglotService parkinglotService;
@Resource
IOrderService orderService;
@Resource
IOperationService ControlService;
@Resource
VehicleMapper vehicleMapper;
@Resource
RedisTemplate<String, Object> redisTemplate;
final Logger logger = LoggerFactory.getLogger(VehicleUnLock.class);
/***
* 合作伙伴ID
*/
private String agentId = "CH0110000223";
/***
* 合作伙伴ID
*/
private String chanleId = "31";
/***
* 合作伙伴Key
*/
private String agentKey = "a";
private String agentHost = "https://baoyang.d.edaijia.cn/api/third/2/";
/**
* 获取渠道下所有的商户列表
*
* @param request
* @param response
*/
@RequestMapping("/getbusinesslist")
public void getBusinessList(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "business/listAll";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 获取商户的账号余额
*
* @param request
* @param response
*/
@RequestMapping("/getbalance")
public void getBalance(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "business/balance";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("customerId", request.getParameter("chanleId"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 获取服务支持城市列表
*
* @param request
* @param response
*/
@RequestMapping("/getcitylist")
public void getCityList(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "queryCityList";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 根据CODE获取城市信息
*
* @param request
* @param response
*/
@RequestMapping("/getcity")
public void getCity(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "queryCity";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("code", request.getParameter("code"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 预估金额
*
* @param request
* @param response
*/
@RequestMapping("/predict")
public void getPredict(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "price";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("code", request.getParameter("code"));
params.put("startLng", request.getParameter("startLng"));
params.put("startLat", request.getParameter("startLat"));
params.put("endLng", request.getParameter("endLng"));
params.put("endLat", request.getParameter("endLat"));
params.put("bookingTime", request.getParameter("bookingTime")); // String(yyyyMMddHHmmss)
params.put("customerId", request.getParameter("customerId"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 下单接口
*
* @param request
* @param response
*/
@RequestMapping("/createorder")
public void createOrder(HttpServletRequest request, HttpServletResponse response) {
String customerId = "CH0110000223";
String taskId = request.getParameter("taskid");
MessageResult message = createOrderByTaskId(Integer.valueOf(taskId), customerId);
this.out(response, message);
}
/**
* 取消订单接口
*
* @param request
* @param response
*/
@RequestMapping("/cancelorder")
public void cancelOrder(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "order/cancel";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("orderId", request.getParameter("orderId"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String result = HttpRequestUtil.doPostJson(url, getSendParam(params));
HashMap<String, Object> retObj = JSON.parseObject(result, HashMap.class);
String code = retObj.get("code").toString();
String message = retObj.get("message").toString();
// 下单成功
if (code == "0") {
String orderNo = retObj.get("data").toString();
}
// 下单失败
else {
}
this.out(response, retObj);
}
/**
* 获取订单详情
*
* @param request
* @param response
*/
@RequestMapping("/orderdetail")
public void getOrderDetail(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "order/detail";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("orderId", request.getParameter("orderId"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 获取订单轨迹
*
* @param request
* @param response
*/
@RequestMapping("/ordertrack")
public void getOrderTrack(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "order/recordList";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("orderId", request.getParameter("orderId"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 获取司机代驾轨迹
*
* @param request
* @param response
*/
@RequestMapping("/ordertrace")
public void getOrderTrace(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "order/trace";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("orderId", request.getParameter("orderId"));
params.put("type", request.getParameter("type"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String ret = HttpRequestUtil.doGetJson(url, getSendParam(params));
this.out(response, ret);
}
/**
* 获取司机信息
*
* @param request
* @param response
*/
@RequestMapping("/getdriverinfo")
public void getDriverInfo(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "order/driverInfo";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("orderId", request.getParameter("orderId"));
params.put("type", request.getParameter("type"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String result = HttpRequestUtil.doGetJson(url, getSendParam(params));
JSONObject retObj = JSON.parseObject(result, JSONObject.class);
String code = retObj.get("code").toString();
String message = retObj.get("message").toString();
if (code == "0") {
JSONObject driver = retObj.getJSONObject("data");
} else {
}
this.out(response, retObj);
}
/**
* 获取目的人收车验证码
*
* @param request
* @param response
*/
@RequestMapping("/getverifycode")
public void getVerifyCode(HttpServletRequest request, HttpServletResponse response) {
MessageResult message = new MessageResult();
String orderId = request.getParameter("orderId");
String type = request.getParameter("type");
String code = getVerifyCode(orderId, type);
if (code != null) {
message.setCode("0");
message.setData(code);
message.setMessage("success");
} else {
message.setCode("1");
message.setData(null);
message.setMessage("failure");
}
this.out(response, message);
}
/***
* 获取收车验证码
*
* @param orderId
* @param type
* @return
*/
public String getVerifyCode(String orderId, String type) {
String url = agentHost + "order/verifyCode";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("orderId", orderId);
params.put("type", type);
String sign = getSign(params, agentKey);
params.put("sign", sign);
String result = HttpRequestUtil.doGetJson(url, getSendParam(params));
HashMap<String, Object> retObj = JSON.parseObject(result, HashMap.class);
String code = retObj.get("code").toString();
String message = retObj.get("message").toString();
// String message = retObj.get("message").toString();
if (code.equals("0")) {
String VerifyCode = retObj.get("data").toString();
return VerifyCode;
} else {
return null;
}
}
/**
* 获取历史订单
*
* @param request
* @param response
*/
@RequestMapping("/getorderlist")
public void getOrderList(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "order/queryList";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("startDate", request.getParameter("startDate"));
params.put("endDate", request.getParameter("endDate"));
params.put("pageSize", request.getParameter("pageSize"));
params.put("currentPage", request.getParameter("currentPage"));
params.put("mobile", request.getParameter("mobile"));
params.put("createMobile", request.getParameter("createMobile"));
params.put("customerId", request.getParameter("customerId"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String result = HttpRequestUtil.doGetJson(url, getSendParam(params));
JSONObject retObj = JSON.parseObject(result, JSONObject.class);
String code = retObj.get("code").toString();
String message = retObj.get("message").toString();
if (code == "0") {
JSONObject orderList = retObj.getJSONObject("data");
this.out(response, orderList);
} else {
this.out(response, retObj);
}
}
/**
* 获取车辆信息照片
*
* @param request
* @param response
*/
@RequestMapping("/getcarphotos")
public void getCarPhotos(HttpServletRequest request, HttpServletResponse response) {
String url = agentHost + "order/getCarPhotos";
Map<String, String> params = new HashMap<>();
params.put("orderId", request.getParameter("orderId"));
params.put("channel", chanleId);
params.put("daijiaType", request.getParameter("daijiaType"));
String sign = getSign(params, agentKey);
params.put("sign", sign);
String result = HttpRequestUtil.doGetJson(url, getSendParam(params));
JSONObject retObj = JSON.parseObject(result, JSONObject.class);
String code = retObj.get("code").toString();
String message = retObj.get("message").toString();
if (code == "0") {
JSONObject orderList = retObj.getJSONObject("data");
this.out(response, orderList);
} else {
this.out(response, retObj);
}
}
/**
* 根据车辆Token登陆
*
* @param request
* @param response
*/
@RequestMapping("/logintoken")
public void logintoken(HttpServletRequest request, HttpServletResponse response) {
logger.info("=======================跳转成功================================");
MessageResult message = new MessageResult();
String token = request.getParameter("token");
/*String sql = "SELECT * FROM t_base_task_token WHERE token='" + token
+ "' AND DATE_ADD(createTime,INTERVAL expiresIn MINUTE)>NOW()";*/
TaskToken taskToken =vehicleService.getTaskToken(token);
//List<Map<String, Object>> result = DataBaseUtil.query(sql);
if (taskToken == null) {
message.setCode("10001");
message.setMessage("错误的授权信息");
message.setData(token);
this.out(response, message);
return;
}
String orderId = taskToken.getOrderid().toString();
logger.info("=======================跳转成功orderId=" + orderId + "================================");
String taskId = taskToken.getTaskid().toString();
logger.info("=======================跳转成功taskId=" + taskId + "================================");
String loginUUID = taskToken.getLoginuuid();
logger.info("=======================跳转成功loginUUID=" + loginUUID + "================================");
TaskInfo taskInfo = vehicleUnLockService.selectByPrimaryKey(Integer.parseInt(taskId));
String verifyCode = getVerifyCode(taskInfo.getOutorderid(), "1");
Order order = orderService.selectByPrimaryKey(Integer.valueOf(orderId));
if (order != null && (order.getOrderstatus() == 0 || order.getOrderstatus() == 10)) {
Integer customerId = order.getCustomerid();
Customer cus = customerService.selectByPrimaryKey(customerId);
if (cus != null) {
request.getSession().setAttribute("customer", cus);
}
request.getSession().setAttribute("orderid", orderId);
request.getSession().setAttribute("taskid", taskId);
request.getSession().setAttribute("loginuuid", loginUUID);
request.getSession().setAttribute("token", token);
request.getSession().setAttribute("verifyCode", verifyCode);
try {
response.sendRedirect(request.getContextPath() + "/jsp/agent/vehiclecontrol.jsp");
} catch (IOException e) {
e.printStackTrace();
}
} else {
message.setCode("11001");
message.setMessage("订单不存在或已经过期");
message.setData(token);
this.out(response, message);
}
}
/**
* 车辆控制接口
*
* @param request
* @param response
*/
@RequestMapping("/control")
public void control(HttpServletRequest request, HttpServletResponse response) {
MessageResult message = new MessageResult();
String orderId = request.getParameter("orderid");
String taskid = request.getParameter("taskid");
String token = request.getParameter("token");
String type = request.getParameter("type");
TaskInfo taskInfo = vehicleUnLockService.selectByPrimaryKey(Integer.parseInt(taskid));
Order order = orderService.selectByPrimaryKey(Integer.valueOf(orderId));
if (StringUtils.isBlank(token)) {
message.setCode("10001");
message.setMessage("禁止访问");
message.setData(orderId);
this.out(response, message);
return;
} else if (checkToken(token) == false) {
message.setCode("10002");
message.setMessage("未授权访问");
message.setData(orderId);
this.out(response, message);
return;
}
if (order == null) {
message.setCode("1");
message.setMessage("订单不存在");
message.setData(orderId);
this.out(response, message);
return;
}
if (taskInfo.getTaskstatus()==4 || taskInfo.getTaskstatus()==5){
message.setCode("1");
message.setMessage("任务已完成不能控制车辆");
message.setData(taskInfo.getId());
this.out(response, message);
return;
}
/*
* if (order.getOrderstatus() != 0 && order.getOrderstatus() != 10) {
* message.setCode("2"); message.setMessage("订单编号无效");
* message.setData(orderId); this.out(response, message); return; }
*/
// 订单未取车，更新为已取车
// 通过订单ID获取车辆的SN和Code
IVehicleDevice vehicleDevice = new VehicleDevice(vehicleMapper.selectByPrimaryKey(order.getVehicleid()));
int result = 0;
switch (type) {
case "0":
result = vehicleDevice.speak();
break;
case "1":
if (order.getOrderstatus() == 0) {//开锁成功后才更新订单状态
order.setChargingstartdate(new Date());
order.setOrderstatus(10);
orderService.updateByPrimaryKeySelective(order);
}
result = vehicleDevice.turnOnAndOpen();
taskInfo.setTaskstatus(2);// 开锁成功后更新任务状态
vehicleUnLockService.updateTaskInfoId(taskInfo);
List<Integer> list = this.vehicleUnLockService.selectByPrimaryKeyVehidInt(taskInfo.getVehicleid());
if (list != null && list.size() > 0) {//开锁成功后删除车位关系完成任务会从新绑定车位关系
vehicleUnLockService.deleteByPrimaryKeyForEach(list);
}
break;
case "2":
result = vehicleDevice.shutDown();
break;
default:
break;
}
message.setCode("0");
message.setMessage("操作成功");
message.setData(result);
this.out(response, message);
return;
}
/**
* 获取车辆信息
*
* @param request
* @param response
*/
@RequestMapping("/getvehicleinfo")
public void getvehicleinfo(HttpServletRequest request, HttpServletResponse response) {
MessageResult message = new MessageResult();
String orderId = request.getParameter("orderId");
String token = request.getParameter("token");
String type = request.getParameter("type");
Order order = orderService.selectByPrimaryKey(Integer.valueOf(orderId));
if (order == null) {
message.setCode("1");
message.setMessage("订单不存在");
message.setData(orderId);
this.out(response, message);
return;
}
// 通过订单ID获取车辆的SN和Code
IVehicleDevice vehicleDevice = new VehicleDevice(vehicleMapper.selectByPrimaryKey(order.getVehicleid()));
QueryResult qr = vehicleDevice.queryInfo();
CarState carSate = qr.getCarState();
this.out(response, carSate);
}
/**
* 更改订单状态主动通知接口
*
* @param request
* @param response
*/
@RequestMapping("/changeorder")
public void changeOrder(HttpServletRequest request, HttpServletResponse response) {
logger.info("============================E代驾回调成功==========================================");
Date now = new Date();
MessageResult message = new MessageResult();
String channel = request.getParameter("channel");
logger.info(
"============================E代驾回调成功：channel" + channel + "==========================================");
String orderId = request.getParameter("orderId");
logger.info(
"============================E代驾回调成功：orderId" + orderId + "==========================================");
String status = request.getParameter("status"); // 订单状态 Int 是 状态值参考订单详情
logger.info(
"============================E代驾回调成功：status" + status + "==========================================");
String driverNo = request.getParameter("driverNo"); // 司机工号 String
// ，司机抢单后或者客服派单后不为空
if (StringUtils.isNotEmpty(driverNo)) {
logger.info("============================E代驾回调成功：driverNo" + driverNo
+ "==========================================");
} else {
logger.info("============================E代驾回调成功：driverNo" + null
+ "==========================================");
}
String sign = request.getParameter("sign"); // 签名 String 是
logger.info("============================E代驾回调成功：sign" + sign + "==========================================");
Map<String, String> params = new HashMap<>();
params.put("channel", channel);
params.put("orderId", orderId);
params.put("status", status);
params.put("driverNo", driverNo);
String vsign = getSign(params, agentKey);
logger.info("============================E代驾回调成功:" + vsign + "==========================================");
/************
* 订单状态说明 0 已下单 2 资金已冻结 5 订单取消 用户取消、司机取消、坐席取消或者客服取消 6 等待司机接单 4 司机已接单
* 调用司机抢单模式的时候通知，调用派单模式则跳过此状态 7 司机已开启订单 8 司机已就位 11 司机开车中 12 司机到达目的地 50
* 已收车 55 订单已完成
************/
if (!vsign.equals(sign)) {
logger.info("============================E代驾回调成功验证不一致==========================================");
message.setCode("1");
message.setMessage("签名错误");
message.setData(vsign);
this.out(response, message);
return;
}
/***** 根据订单号订单号获取任务编号 ********/
TaskInfo taskInfo = vehicleTaskService.selectByOutOrderId(orderId);
if (taskInfo == null) {
message.setCode("3");
message.setMessage("订单不存在");
message.setData(orderId);
this.out(response, message);
return;
}
/*** 获取司机信息，发送短信 *****/
if (status.equals("6") || status.equals("4") || status.equals("7")) {
String verifyCode = getVerifyCode(taskInfo.getOutorderid(), "1");// 获取验证码
// add
// cjl
taskInfo.setOrderkey(verifyCode);
String url = agentHost + "order/driverInfo";
Map<String, String> sendParams = new HashMap<>();
sendParams.put("channel", chanleId);
sendParams.put("orderId", orderId);
sign = getSign(sendParams, agentKey);
sendParams.put("sign", sign);
String result = HttpRequestUtil.doGetJson(url, getSendParam(sendParams));
GsonBuilder gb = new GsonBuilder();
Gson g = gb.create();
Map<Object, Object> map1 = g.fromJson(result, new TypeToken<Map<Object, Object>>() {
}.getType());
String code = map1.get("code").toString();
Double codeInt = Double.parseDouble(code);
if (codeInt.intValue() == 0) {
String data = g.toJson(map1.get("data"));
Map<Object, Object> map2 = g.fromJson(data, new TypeToken<Map<Object, Object>>() {
}.getType());
String driverId = "";
String driverPhone = "";
String name = "";
String pictureSmall = "";
String pictureMiddle = "";
String pictureLarge = "";
String idCard = "";
if (map2.get("driverId") != null) {
driverId = map2.get("driverId").toString();
}
if (map2.get("driverPhone") != null) {
driverPhone = map2.get("driverPhone").toString();
}
if (map2.get("name") != null) {
name = map2.get("name").toString();
}
if (map2.get("newLevel") != null) {
Double newLeveld = Double.parseDouble(map2.get("newLevel").toString());
Integer newLevel = newLeveld.intValue();
}
if (map2.get("pictureSmall") != null) {
pictureSmall = map2.get("pictureSmall").toString();
}
if (map2.get("pictureMiddle") != null) {
pictureMiddle = map2.get("pictureMiddle").toString();
}
if (map2.get("pictureLarge") != null) {
pictureLarge = map2.get("pictureLarge").toString();
}
if (map2.get("year") != null) {
Double yeard = Double.parseDouble(map2.get("year").toString());
Integer year = yeard.intValue();
}
if (map2.get("idCard") != null) {
idCard = map2.get("idCard").toString();
}
//
if (StringUtils.isBlank(driverPhone)) {
message.setCode("2");
message.setMessage("无法获取司机信息");
message.setData(orderId);
this.out(response, message);
return;
} else {
CarManager carManager = this.carManagerService.selectByMobile(driverPhone);
if (carManager == null) {
carManager = new CarManager();
carManager.setUsername(driverPhone);
carManager.setName(name);
carManager.setDrivinglicensephoto(pictureSmall);
carManager.setMobile(driverPhone);
if (map2.get("driverId") != null) {
carManager.setRemark("e代驾司机:" + driverId + ",身份证:" + idCard);
} else {
carManager.setRemark("e代驾司机:" + null + ",身份证:" + idCard);
}
carManager.setIdphoto(idCard);
try {
carManager.setPassword(EncryptionUtil.md5(ConstantUtil.CAR_MANAGER_INITPWD));
} catch (Exception e1) {
e1.printStackTrace();
}
carManager.setWorkstatus(ConstantUtil.WORKSTATUS);
carManager.setTaskstatus(ConstantUtil.TASKSTATUS);
carManager.setCreatedate(now);
carManager.setSex(0);
carManager.setIdphoto("e代驾人员");
carManager.setHoldingidphoto("e代驾人员");
carManager.setDrivinglicensephoto("e代驾人员");
this.carManagerService.insertManager(carManager);
// 获取司机ID
carManager = this.carManagerService.selectByMobile(driverPhone);
}
Customer cus = new Customer();
cus.setUsername(driverPhone);
cus.setName(name);
cus.setIdcardno(idCard);
cus.setIsValidateIdCard(new Byte("1"));
cus.setIsValidateDrivingLicence(new Byte("1"));
cus.setIsCompany(new Byte("1"));
cus.setCompanyID(152);// 后续在该暂时没有想到取E代驾企业的方法
cus.setCompanyName(AGENT_COMPANY_NAME);
cus.setAuditstatus(new Byte("1"));
cus.setIscanorder(new Byte("1"));
cus.setMobile(driverPhone);
cus.setSourcechannelid(1);
cus.setCreatedate(new Date());
cus.setDepartmentid(223);//E代驾使用部门ID
try {
cus.setPassword(EncryptionUtil.md5(ConstantUtil.CAR_MANAGER_INITPWD));
} catch (Exception e) {
e.printStackTrace();
}
Customer tempCus = customerService.isExistCustomer(cus);
// 如果用户不存在,注册新用户
if (tempCus == null) {
// 获取注册模板的信息
MessageTemplate mTemplate = messageTemplateService
.selectTitleAndContentByIdentification(ConstantUtil.M_REGISTER_SUCCESS);
net.joystart.customer.entity.Message mes = null;
if (mTemplate != null) {
// 添加站内信
mes = new net.joystart.customer.entity.Message();
mes.setTitle(mTemplate.getTitle());
mes.setContent(mTemplate.getContent());
mes.setSenddate(new Date());
mes.setReadstatus(new Byte("0"));
mes.setIsdelete(new Byte("0"));
mes.setCreatedate(new Date());
}
cus = customerService.Register(cus, mes);
} else {
cus.setId(tempCus.getId());
}
// 更新用户UUID
UUID uuid = UUID.randomUUID();
cus.setLoginUUID(uuid.toString());
customerService.updaeCustomer(cus);
message = acceptTask(taskInfo.getId().toString(), carManager, cus);
this.out(response, message);
return;
}
} else {
message.setCode("2");
message.setMessage("无法获取司机信息");
message.setData(orderId);
this.out(response, message);
return;
}
} else if (status.equals("5")) {
if (cancelOrderByTask(taskInfo.getId())) {
message.setCode("0");
message.setMessage("success");
this.out(response, message);
return;
} else {
message.setCode("4");
message.setMessage("取消订单失败");
message.setData(orderId);
this.out(response, message);
return;
}
} else if (status.equals("50")) // 已收车
{
message.setCode("0");
message.setMessage("success");
this.out(response, message);
return;
} else if (status.equals("55")) // 已完成
{
message.setCode("0");
message.setMessage("success");
this.out(response, message);
return;
} else {
message.setCode("0");
message.setMessage("success");
this.out(response, message);
return;
}
}
/**
* 领取任务
*
* @param request
* @param response
*/
public MessageResult acceptTask(String taskId, CarManager carManager, Customer cus) {
MessageResult message = new MessageResult();
try {
if (taskId == null) {
message.setCode(ConstantUtil.M_EXCEPTION);
message.setMessage("参数taskId不能为空");
return message;
}
if (vehicleTaskService.IsCanAcceptTask(Integer.valueOf(taskId))) {
message.setCode(ConstantUtil.M_EXCEPTION);
message.setMessage("当前车辆已被用户下单,请联系管理人员删除此任务");
return message;
}
TaskInfo taskInfo = vehicleTaskService.selectByPrimaryKey(Integer.valueOf(taskId));
if (taskInfo.getTaskstatus() != 0 && taskInfo.getTaskuserid() != null) {
message.setCode(ConstantUtil.M_EXCEPTION);
message.setMessage("这个任务已经分配给了其他人");
return message;
}
// 判断是充电，且有调度
if (taskInfo.getTaskimg() != null && taskInfo.getTaskimg().intValue() == 0
&& taskInfo.getDispatchType().intValue() == 3) {
taskInfo.setTaskimg(5);
}
VehicleLock lock = new VehicleLock(taskInfo.getVehicleid().toString());
String ret = lock.wrap(new Callable<String>() {
@Override
public String call() {
String uuid = cus.getLoginUUID();
MessageResult result = new MessageResult();
InstantOrder instantOrder = new InstantOrder();
instantOrder.setCustomerId(cus.getId());
instantOrder.setVehicleId(taskInfo.getVehicleid());
instantOrder.setIsEnterprise(new Byte("1"));
instantOrder.setLoginUUID(uuid);
String token = StringUtil.getRandomString(8, ConstantUtil.REDPACKET_NUMBER_SEEDSOURCE);
/*** 生成随机控制密码 ***/
try {
token = EncryptionUtil.md5(token + uuid);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
// 订单来源代驾
instantOrder.setSourceType(4);
// 插入订单
result = orderService.insertInstantOrder(instantOrder);
HashMap<String, Object> orderMap = new HashMap<String, Object>();
// dataMap.put("orderId", orderId);
if (result != null) {
orderMap = (HashMap<String, Object>) result.getData();
}
// IVehicleService vehicleService;
String orderId = orderMap.get("orderId").toString();
taskInfo.setAllocationtime(new Date());
taskInfo.setTaskstatus(1);
taskInfo.setTaskuserid(carManager.getId());
taskInfo.setOrderid(Integer.valueOf(orderId)); // 设置订单关联任务
// taskInfo.setOrderkey(orderLoginCode);
taskInfo.setExpires(EXPIRES_IN);
vehicleTaskService.acceptTask(taskInfo);
int taskType = taskInfo.getTasktype();
String temp = "充电";
if (0 == taskType) {
temp = "充电";
} else if (1 == taskType) {
temp = "调度";
} else if (2 == taskType) {
temp = "整备";
} else if (3 == taskType) {
temp = "调度充电";
} else if (4 == taskType) {
temp = "加油";
}
Vehicle vh = vehicleService.selectByPrimaryKey(taskInfo.getVehicleid());
// 插入登录信息
/*String sql = "insert into `t_base_task_token`(orderid,taskid,loginUUID,token,expiresIn,createTime) values("
+ orderId + "," + taskId.toString() + ",'" + cus.getLoginUUID() + "','" + token + "',"
+ EXPIRES_IN + ",'" + new Date() + "')";*/
//DataBaseUtil.query(sql);
TaskToken taskToken = new TaskToken();
taskToken.setCreatetime(new Date());
taskToken.setOrderid(Integer.parseInt(orderId));
taskToken.setTaskid(Integer.parseInt(taskId));
taskToken.setLoginuuid(cus.getLoginUUID());
taskToken.setToken(token);
taskToken.setExpiresin(EXPIRES_IN);
vehicleService.insertSelectiveTaskToken(taskToken);
carManagerLogService.insertLog(carManager.getId(), "接受" + temp + "任务 车牌号:"
+ (vh != null ? vh.getPlatenumber() : "未知") + "
任务单号:" + taskInfo.getTaskNo());
/*********************
* 发送短信任务链接给代驾人员
******************/
String taskurl = "http://t.bagechuxing.cn/l/" + token;
PostMsgHttpContent.sendMessage("13401149982", "您成功领取了任务,点击以下链接完成任务 " + taskurl);
return "SUCCESS";
}
});
if ("SUCCESS".equals(ret)) {
message.setCode(ConstantUtil.M_SUCCESS);
message.setMessage("接受任务成功");
} else {
message.setCode(ConstantUtil.M_SYSTEM_ERROR);
message.setMessage("系统异常");
}
return message;
} catch (Exception e) {
e.printStackTrace();
message.setCode(ConstantUtil.M_SYSTEM_ERROR);
message.setMessage("系统异常");
return message;
}
}
/***
* 根据任务生成e代驾订单
*
* @param taskid
*/
public MessageResult createOrderByTaskId(Integer taskId, String customerId) {
MessageResult message = new MessageResult();
if (vehicleTaskService.IsCanAcceptTask(taskId)) {
message.setCode(ConstantUtil.M_EXCEPTION);
message.setMessage("当前车辆已被用户下单,请联系管理人员删除此任务");
return message;
}
TaskInfo taskInfo = vehicleTaskService.selectByPrimaryKey(taskId);
if (taskInfo.getTaskstatus() != 0 && taskInfo.getTaskuserid() != null) {
message.setCode(ConstantUtil.M_EXCEPTION);
message.setMessage("这个任务已经分配给了其他人");
return message;
}
Integer vehicleId = taskInfo.getVehicleid();
Vehicle vehicle = vehicleService.selectByPrimaryKey(vehicleId);
Integer parkId = vehicle.getParkid();
Parkinglot parkinglot = parkinglotService.selectParkinglotByPrimaryKey(parkId);
if (parkinglot == null) {
message.setCode(ConstantUtil.M_EXCEPTION);
message.setMessage("该车未在任何车场");
return message;
}
Calendar cal = Calendar.getInstance();
cal.add(Calendar.MINUTE, +31);
SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss");
String url = agentHost + "order/create";
Map<String, String> params = new HashMap<>();
params.put("channel", chanleId);
params.put("customerId", customerId);
params.put("type", "1"); // 订单类型 Int 是 1-取送车
params.put("mode", "1"); // 订单成单模式 1-司机抢单（订单所在城市预约开启时生效，否则为客服派单） 0-客服派单
params.put("createMobile", parkinglot.getTelephone()); // 下单人手机号 String
// 是 手机号
params.put("mobile", parkinglot.getTelephone()); // 车主手机号 String 是 手机号
params.put("username", "巴歌出行"); // 车主姓名 String 是
params.put("pickupContactName", "巴歌出行"); // 取车地址联系人姓名 String 是 最多20个字符
params.put("pickupContactPhone", parkinglot.getTelephone()); // 取车地址联系人手机号
// String
// 是 手机号
params.put("pickupAddress", parkinglot.getAddress()); // 取车地址 String 是
// 最多100个字符
params.put("pickupAddressLng", parkinglot.getLongitude()); // 取车地址经度
// Double 是
params.put("pickupAddressLat", parkinglot.getLatitude()); // 取车地址纬度
// Double 是
params.put("returnContactName", "巴歌出行"); // 还车地址联系人姓名 String 是 最多20个字符
params.put("returnContactPhone", "13401149982"); // 还车地址联系人手机号
// String
// 是 手机号
List<DrivingTrack> listTack = null;
listTack = vehicleService.getAllCarsPoint(vehicle.getSn());
if (listTack != null && listTack.size() > 0) {
DrivingTrack dt = new DrivingTrack();
dt = listTack.get(0);
params.put("returnAddressLng", dt.getLongitude().toString()); // 还车地址经度
// Double
// 是
params.put("returnAddressLat", dt.getLatitude().toString()); // 还车地址纬度
// Double
// 是
}
String returnAddress = BaiDuAPIUtil.getDetailByGPS(
Double.parseDouble(params.get("returnAddressLng").toString()),
Double.parseDouble(params.get("returnAddressLat").toString()));
GsonBuilder gb = new GsonBuilder();
Gson g = gb.create();
Map<Object, Object> mapOne = g.fromJson(returnAddress, new TypeToken<Map<Object, Object>>() {
}.getType());
Map<Object, Object> mapTwo = (Map<Object, Object>) mapOne.get("result");
String strOne = mapTwo.get("formatted_address").toString();
params.put("returnAddress", strOne); // 还车地址 String 是
// 最多100个字符
params.put("bookingTime", sdf.format(cal.getTime())); // 预约时间 String
// (yyyyMMddHHmmss)
// 是
// 必须比当前时间晚至少半个小时
params.put("carNo", vehicle.getPlatenumber()); // 车牌号 String 是
params.put("carBrandName", vehicle.getCarname()); // 车辆品牌名称 String 否
// 最多50个字符
params.put("carSeriesName", vehicle.getCarname()); // 车辆品牌名称 String 否
// 最多50个字符
String sign = getSign(params, agentKey);
params.put("sign", sign);
String result = HttpRequestUtil.doPostJson(url, getSendParam(params));
logger.info("e代驾下单接口调用:" + params + ",返回结果:" + result);
HashMap<String, Object> retObj = JSON.parseObject(result, HashMap.class);
String code = retObj.get("code").toString();
String msg = retObj.get("message").toString();
/**** 更新外部订单号 *****/
if (code.equals("0")) {
String orderNo = retObj.get("data").toString();
/*
* String verifyCode = getVerifyCode(orderNo, "1"); if (verifyCode
* == null) { message.setCode(ConstantUtil.M_EXCEPTION);
* message.setMessage("获取验证码失败"); return message; } else {
* taskInfo.setOrderkey(verifyCode);
* taskInfo.setOutorderid(orderNo);
* vehicleTaskService.acceptTask(taskInfo);
* message.setCode(ConstantUtil.M_SUCCESS);
* message.setMessage("SUCCESS"); message.setData(orderNo); return
* message; }
*/
taskInfo.setOutorderid(orderNo);
taskInfo.setEdFlag(1);//推送成功
taskInfo.setEdCreateDate(new Date());
vehicleTaskService.acceptTask(taskInfo);
logger.info("=================" + retObj.get("data").toString() + "====================");
message.setCode(ConstantUtil.M_SUCCESS);
message.setMessage("推送成功");
return message;
} else {
message.setCode(ConstantUtil.M_EXCEPTION);
message.setMessage("推送失败");
return message;
}
}
/***
* 取消订单接口
*/
private boolean cancelOrderByTask(Integer taskId) {
try {
TaskInfo taskInfo = vehicleTaskService.selectByPrimaryKey(taskId);
if (taskInfo != null) {
taskInfo.setIsdelete(1);
vehicleTaskService.cancle(taskId);
Integer orderId = taskInfo.getOrderid();
if (orderId != null) {
Order o = orderService.selectByPrimaryKey(orderId);
Order order = new Order();
order.setId(new Integer(orderId));
order.setOrderstatus(40);
orderService.updateByPrimaryKeySelective(order);
redisTemplate.opsForHash().delete(ConstantUtil.ORDER_CACHE_KEY, o.getOrderno());
Vehicle vehicle = new Vehicle(o.getVehicleid(), VehicleStatus.CANRENT.getValue());
vehicleService.updateByPrimaryKeySelective(vehicle);
}
return true;
} else {
return false;
}
} catch (Exception ex) {
Log4jTask.addLog("结束订单报错", System.currentTimeMillis(), Log4jTask.ERROR, OrderController.class.getName(),
ex);
return false;
}
}
/**
* @author 完成任务商任务完成接口
*/
@Transactional
@RequestMapping("/finishTask")
public void taskfinish(HttpServletResponse response, HttpServletRequest request) {
MessageResult messageResult = new MessageResult();
String taskid = request.getParameter("taskid");
String imgUrl = request.getParameter("imgUrl");
String imgUrlTwo = request.getParameter("imgUrlTwo");
String accidentType = request.getParameter("accidentType");
String parkid = request.getParameter("parkid");
String branchid = request.getParameter("branchid");
// 整备id插入整备信息表
String reorgids = request.getParameter("reorgids");
logger.info("=================任务ID" + taskid + "=================================");
logger.info("=================完成状态" + accidentType + "===========================");
logger.info("=================车场ID" + parkid + "=================================");
logger.info("=================网点" + branchid + "=================================");
logger.info("=================整备" + reorgids + "=================================");
try {
VehicleSite vs = new VehicleSite();
TaskInfo taskInfo = vehicleUnLockService.selectByPrimaryKey(Integer.parseInt(taskid));
taskInfo.setAccidentType(Integer.parseInt(accidentType));
Integer orderId = taskInfo.getOrderid();
Order order = orderService.selectByPrimaryKey(orderId);
int result = 0;
// 结束订单信息
if (order != null) {
Integer customerId = order.getCustomerid();
result = ControlService.vehicleControl(customerId, orderId, 3, null, null, "2",2);
}
if (StringUtils.isEmpty(parkid) && StringUtils.isEmpty(branchid)) {
Vehicle vh = vehicleService.selectByPrimaryKey(taskInfo.getVehicleid());
int siteid = selectSiteid(vh.getSn());
if (siteid != 0) {
vs.setId(siteid);
} else {
Map<String, Object> params = new HashMap<String, Object>();
HashMap<String, Object> dataMap = new HashMap<>();
List<Position> list = VehicleControlUtil.getVehicleLocationBaiDuAndCarLifeFromSn(vh.getSn());
Position position = list.get(0);
ServiceCity city = null;
// 通过坐标获取城市信息
city = this.cityService.getBaiduServiceCityByGPS(position.getX(), position.getY());
params.put("cityId", city.getId());
Parkinglot parkinglot = parkinglotService.findParkinglotCanCharging(params, position.getX(),
position.getY());
if (parkinglot == null) {
messageResult.setData(dataMap);
messageResult.setCode(ConstantUtil.M_EXCEPTION);
messageResult.setMessage("车辆在允许的还车区域内");
this.out(response, messageResult);
return;
}
if (parkinglot.getParktype() != null) {
EfenceBaseType efenceType;
try {
efenceType = EfenceBuilder.BuildEfence(parkinglot.getParktype(),
parkinglot.getCoordinatepoints());
EfenceState efenceState = efenceType.GetEfenceState(Double.parseDouble(position.getX()),
Double.parseDouble(position.getY()));
if (EfenceState.In.equals(efenceState)) {
parkid = String.valueOf(parkinglot.getCountyid());
branchid = String.valueOf(parkinglot.getId());
}
} catch (Exception e) {
messageResult.setCode(ConstantUtil.M_EXCEPTION);
messageResult.setMessage("获取站点围栏信息错误");
this.out(response, messageResult);
return;
}
}
if (StringUtils.isBlank(branchid)) {
messageResult.setCode(ConstantUtil.M_EXCEPTION);
messageResult.setMessage("车辆未在允许的还车区域内");
this.out(response, messageResult);
return;
}
}
}
VehicleLock lock = new VehicleLock(taskInfo.getVehicleid().toString());
String branchId = branchid;
String parkId = parkid;
String ret = lock.wrap(new Callable<String>() {
@Override
public String call() {
if (taskInfo != null && taskInfo.getTaskstatus() != 1 && taskInfo.getTaskstatus() != 0) {
if (taskInfo.getTaskstatus() == 4) {
logger.info("当前任务已完成，请刷新 " + taskInfo.getId());
return ConstantUtil.M_PARAMTER_NULL;
} else {
if (branchId != null && !"".equals(branchId)) {
List<VehicleSite> list = vehicleUnLockService
.getVehicleSiteLists(Integer.parseInt(branchId));
if (list.size() == 0) {
logger.info("该网点暂无车位" + taskInfo.getId());
return ConstantUtil.M_SITENO;
}
} else {
if (parkId != null && !"".equals(parkId)) {
List<VehicleSite> list = vehicleUnLockService
.getVehicleSiteList(Integer.parseInt(parkId));
if (list.size() == 0) {
logger.info("该网点暂无车位" + taskInfo.getId());
return ConstantUtil.M_SITENO;
}
}
}
Calendar now = Calendar.getInstance(); // 获取当前系统时间
Calendar calendar = Calendar.getInstance();
calendar.setTime(taskInfo.getAllocationtime());
long timeOne = now.getTimeInMillis();
long timeTwo = calendar.getTimeInMillis();
boolean flag = true;
// 校验超时日期是否小于一分钟 add cjl
if (taskInfo.getChargingtime() != null) { // 充电任务
Long min = UtilTimeFormatter.seconds(new Date(), taskInfo.getAllocationtime(),
taskInfo.getChargingtime(), taskInfo.getCountdown());
if (min != null && min < 60) {
flag = false;
}
} else {
Long min = UtilTimeFormatter.seconds(new Date(), taskInfo.getAllocationtime(), null,
taskInfo.getCountdown());
if (min != null && min < 60) {
flag = false;
}
}
if (flag) {
if (taskInfo.getAllocationtime() != null && taskInfo.getTasktype() == 0) {
if (taskInfo.getChargingtime() != null
&& taskInfo.getChargingtime().toString().equals("0.5")) {// 充电时间为半个小时
int minute = new Long((timeOne - timeTwo) / (1000 * 60)).intValue();// 转化minute搜索
if (taskInfo.getCountdown() != null
&& (minute - 30) > taskInfo.getCountdown()) {
taskInfo.setTimeout(minute - taskInfo.getCountdown() - 30);
}
} else if (taskInfo.getChargingtime() != null
&& taskInfo.getChargingtime().toString().equals("1")) {// 充电时间为一个小时
int minute = new Long((timeOne - timeTwo) / (1000 * 60)).intValue();// 转化minute搜索
if (taskInfo.getCountdown() != null
&& (minute - 60) > taskInfo.getCountdown()) {
taskInfo.setTimeout(minute - taskInfo.getCountdown() - 60);
}
} else if (taskInfo.getChargingtime() != null
&& taskInfo.getChargingtime().toString().equals("1.5")) {// 一个半小时
int minute = new Long((timeOne - timeTwo) / (1000 * 60)).intValue();// 转化minute搜索
if (taskInfo.getCountdown() != null
&& (minute - 90) > taskInfo.getCountdown()) {
taskInfo.setTimeout(minute - taskInfo.getCountdown() - 90);
}
} else if (taskInfo.getChargingtime() != null
&& taskInfo.getChargingtime().toString().equals("2")) {// 俩个小时
int minute = new Long((timeOne - timeTwo) / (1000 * 60)).intValue();// 转化minute搜索
if (taskInfo.getCountdown() != null
&& (minute - 120) > taskInfo.getCountdown()) {
taskInfo.setTimeout(minute - taskInfo.getCountdown() - 120);
}
} else if (taskInfo.getChargingtime() == null
|| taskInfo.getChargingtime().toString().equals("")) {
int minute = new Long((timeOne - timeTwo) / (1000 * 60)).intValue();// 转化minute搜索
if (taskInfo.getCountdown() != null && minute > taskInfo.getCountdown()) {
taskInfo.setTimeout(minute - taskInfo.getCountdown());
}
}
} else {
int minute = new Long((timeOne - timeTwo) / (1000 * 60)).intValue();// 转化minute搜索
if (taskInfo.getCountdown() != null && minute > taskInfo.getCountdown()) {
taskInfo.setTimeout(minute - taskInfo.getCountdown());
}
}
} else {
taskInfo.setTimeout(0);// 小于1分钟
}
if (accidentType != null && !accidentType.equals("")) {
taskInfo.setAccidentType(Integer.parseInt(accidentType));
}
taskInfo.setAccomplishtime(new Date());
int res = vehicleUnLockService.updateByPrimaryKeySelective(reorgids, taskInfo, imgUrl,
imgUrlTwo, parkId, branchId, vs);
if (res == 1) {
Vehicle vh = vehicleService.selectByPrimaryKey(taskInfo.getVehicleid());
carManagerLogService.insertLog(taskInfo.getTaskuserid(),
TaskType.valueOf(taskInfo.getTasktype()).getName() + " 任务完成 车牌号:"
+ (vh != null ? vh.getPlatenumber() : "未知") + "
任务单号:"
+ taskInfo.getTaskNo());
logger.info("任务完成" + taskInfo.getId());
return ConstantUtil.M_SUCCESS;
} else {
logger.info("任务完成失败了，请稍后再试" + taskInfo.getId());
return String.valueOf(res);
}
}
} else {
logger.info("请操作开锁功能" + taskInfo.getId());
return ConstantUtil.M_PARAMTER_NULL;
}
}
});
if (ret.equals(ConstantUtil.M_SUCCESS)) {
messageResult.setData(taskInfo.getOrderkey());
messageResult.setCode(ConstantUtil.M_SUCCESS);
messageResult.setMessage("任务完成成功");
this.out(response, messageResult);
} else {
messageResult.setData("0");
messageResult.setCode(ret);
messageResult.setMessage("任务完成失败");
this.out(response, messageResult);
}
} catch (Exception ex) {
messageResult.setData("");
messageResult.setCode(ConstantUtil.M_EXCEPTION);
messageResult.setMessage("任务完成失败");
this.out(response, messageResult);
ex.printStackTrace();
}
}
/***
* 根据任务生成e代驾订单（静态方法供外部调用）
*
* @param taskid
*/
public static MessageResult createOrderByTask(Integer taskId, String customerId) {
AgentController agent = new AgentController();
return agent.createOrderByTaskId(taskId, customerId);
}
/***
* 选择站点
*
* @param sn
* @return
*/
@SuppressWarnings("unchecked")
public int selectSiteid(String sn) {
int result = 0;
int parkId = 0;
int branchId = 0;
Integer siteID = 0;
String str = VehicleControlUtil.getGpsInfoFromSn(sn); // 获取原始GPS坐标 ADD
// CJL
if (str != null && !"".equals(str)) {
Map<Object, Object> m = JSONProcesser.parseDataToMap(str);
if ((double) m.get("result") == 1 && m.get("cars") != null
&& ((List<Map<Object, Object>>) m.get("cars")).size() > 0) {
List<Map<Object, Object>> listdetail = (List<Map<Object, Object>>) m.get("cars");
if (listdetail != null && listdetail.size() > 0) {
Map<Object, Object> map = listdetail.get(0);
String lat = map.get("latitude").toString();
String lon = map.get("longitude").toString();
List<Parkinglot> parkList = getEfenceByGPS(Double.parseDouble(lon), Double.parseDouble(lat), 1);
if (parkList == null || parkList.size() == 0) {
// 车辆不在任何还车区域内
return result;
} else {
int type = 0; // 0车场 1网点
// 调用接口判断车辆是否在还车区域内，如果在返回网点或车场的id
for (int i = 0; i < parkList.size(); i++) {
Parkinglot parkinglot = parkList.get(i);
if (parkinglot.getParktype() != null) {
EfenceBaseType efenceType;
try {
efenceType = EfenceBuilder.BuildEfence(parkinglot.getParktype(),
parkinglot.getCoordinatepoints());
EfenceState efenceState = efenceType.GetEfenceState(Double.parseDouble(lon),
Double.parseDouble(lat));
if (EfenceState.In.equals(efenceState)) {
parkId = parkinglot.getCountyid();
branchId = parkinglot.getId();
type = parkinglot.getStatus();
break;
}
} catch (Exception e) {
// TODO Auto-generated catch block
// e.printStackTrace();
}
}
}
// 如果等于0 说明所有区域都不符合还车条件
if (parkId == 0 && branchId == 0) {
return result;
}
// 根据返回的车场或网点id，查找是否有车位可以进行还车
if (type == 0) {
// 如果是车场
siteID = this.vehicleUnLockService.selectSiteIDByID(parkId);
branchId = 0;
if (siteID == null) {
return 0;
}
return siteID;
} else {
// 如果是网点
siteID = this.vehicleUnLockService.selectSiteIDByBranchID(branchId);
if (siteID == null) {
return 0;
}
return siteID;
}
}
}
return result;
}
return result;
}
return result;
}
/***
* 通过当前车辆GPS点获取可以使用的车场或网点还车范围信息
*
* @param lng
* @param lat
* @param Type
* @return
*/
public List<Parkinglot> getEfenceByGPS(double lng, double lat, int Type) {
ReturnForInterface rfi = new ReturnForInterface();
String resutl = TengXunAPIUtil.getDetailByGPS(lng, lat, Type);
if (!StringUtils.isBlank(resutl)) {
// 将地图返回json转化为实体
net.joystart.mapCoordinates.entity.ReturnResult RR = (net.joystart.mapCoordinates.entity.ReturnResult) JSONProcesser
.jsonProcesser(resutl, net.joystart.mapCoordinates.entity.ReturnResult.class);
if (RR != null) {
// 获取城市的名称
String CityName = RR.getResult().getAddress_component().getCity();
// 获取城市名称的前2个字
String smallCityName = "";
if (!StringUtils.isBlank(resutl) && !StringUtils.isBlank(CityName)) {
smallCityName = CityName.substring(0, 2);
}
// 根据2个城市名字筛选获取所有城市对应的id
Map<String, Object> params = new HashMap<String, Object>();
params.put("fullname", "%" + CityName + "%");
params.put("name", "%" + smallCityName + "%");
// 获取当前时间的小时和分钟
Calendar calendar_as = Calendar.getInstance();
Date dtnow = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("HHmm");
String curtime = sdf.format(dtnow);
params.put("minsec", Integer.valueOf(curtime));
return vehicleUnLockService.selectEfenceByCity(params);
}
}
return null;
}
/***
* 生成e代驾签名
*
* @param params
* @param md5_key
* @return
*/
public boolean checkToken(String token) {
String sql = "SELECT * FROM t_base_task_token WHERE token='" + token + "'";
List<Map<String, Object>> result = DataBaseUtil.query(sql);
if (result == null || result.size() == 0) {
return false;
}
return true;
}
/***
* 生成e代驾签名
*
* @param params
* @param md5_key
* @return
*/
public String getSign(Map<String, String> params, String md5_key) {
Map<String, String> sParaNew = paraFiltere(params);
String preSignStr = createLinkString(sParaNew);
String tmp = sign(preSignStr);
return sign(tmp + md5_key);
}
/**
* 除去数组中的空值和签名参数
*
* @param sArray
* 签名参数组
* @return 去掉空值与签名参数后的新签名参数组
*/
public Map<String, String> paraFilter(Map<String, String> sArray) {
Map<String, String> result = new HashMap<String, String>();
if (sArray == null || sArray.size() <= 0) {
return result;
}
for (String key : sArray.keySet()) {
String value = sArray.get(key);
if (value == null || value.equals("") || key.equalsIgnoreCase("sign") || key.equalsIgnoreCase("msg")) {
continue;
}
result.put(key, value);
}
return result;
}
/**
* 除去数组中的空值和签名参数
*
* @param sArray
* 签名参数组
* @return 去掉空值与签名参数后的新签名参数组
*/
public Map<String, String> paraFiltere(Map<String, String> sArray) {
Map<String, String> result = new HashMap<String, String>();
if (sArray == null || sArray.size() <= 0) {
return result;
}
for (String key : sArray.keySet()) {
String value = sArray.get(key);
if (value == null || value.equals("") || key.equalsIgnoreCase("sign") || key.equalsIgnoreCase("msg")) {
result.put(key, "");
continue;
}
result.put(key, value);
}
return result;
}
/**
* 把数组所有元素排序，并按照“参数=参数值”的模式用“&”字符拼接成字符串
*
* @param params
* 需要排序并参与字符拼接的参数组
* @return 拼接后字符串
*/
public String createLinkString(Map<String, String> params) {
List<String> keys = new ArrayList<String>(params.keySet());
Collections.sort(keys);
String prestr = "";
for (int i = 0; i < keys.size(); i++) {
String key = keys.get(i);
String value = params.get(key);
prestr = prestr + key + "=" + value;
}
return prestr;
}
/**
* 把数组所有元素排序，并按照“参数=参数值”的模式用“&”字符拼接成字符串
*
* @param params
* 需要排序并参与字符拼接的参数组
* @return 拼接后字符串
*/
public String getSendParam(Map<String, String> params) {
List<String> keys = new ArrayList<String>(params.keySet());
Collections.sort(keys);
String prestr = "";
for (int i = 0; i < keys.size(); i++) {
String key = keys.get(i);
String value = params.get(key);
if (i == keys.size() - 1) {
prestr = prestr + key + "=" + value;
} else {
prestr = prestr + key + "=" + value + "&";
}
}
return prestr;
}
/**
* 签名字符串
*
* @param text
* 需要签名的字符串
* @param key
* 密钥
* @param input_charset
* 编码格式
* @return 签名结果
*/
public String sign(String text) {
return DigestUtils.md5Hex(getContentBytes(text));
}
/**
* @param content
* @param charset
* @return
* @throws SignatureException
* @throws UnsupportedEncodingException
*/
private byte[] getContentBytes(String content) {
try {
return content.getBytes(ZCloudSignConfig.charset);
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("MD5签名过程中出现错误,指定的编码集不对,");
}
}
/**
* 故障完成逻辑 add cjl
*/
@RequestMapping("/faultFinishTask")
public void faultFinishTask(HttpServletResponse response, HttpServletRequest request) {
MessageResult messageResult = new MessageResult();
String taskid = request.getParameter("taskid");
if (!taskid.equals("null")) {
TaskInfo taskInfo = vehicleUnLockService.selectByPrimaryKey(Integer.parseInt(taskid));
List<Integer> list = this.vehicleUnLockService.selectByPrimaryKeyVehidInt(taskInfo.getVehicleid());
if (list != null && list.size() > 0) {//防止车位绑定重复 因为故障完成不需要开锁操作无法删除车位关系
vehicleUnLockService.deleteByPrimaryKeyForEach(list);
}
Order order = orderService.selectByPrimaryKey(taskInfo.getOrderid());
order.setOrderstatus(10);
order.setId(taskInfo.getOrderid());
orderService.updateByPrimaryKeySelectiveStaus(order);//故障完成无需开锁，所以订单状体强制改成10
// 结束订单信息
if (taskInfo.getOrderid() != null) {
int result = ControlService.vehicleControl(order.getCustomerid(), order.getId(), 3, null, null, "2",1);
}
Vehicle vehicle = vehicleService.selectByPrimaryKey(taskInfo.getVehicleid());
int recReport = vehicleUnLockService.getFaultReportCount(vehicle.getPlatenumber());
if (recReport > 0) {
messageResult.setCode(ConstantUtil.M_EXCEPTION);
messageResult.setMessage("有未处理完的故障报修，请处理后再上报");
this.out(response, messageResult);
return;
} else {
taskInfo.setTaskstatus(5);
int res = vehicleUnLockService.updateTaskInfo(taskInfo);
if (res != 0) {
MessageTemplate mTemplate = messageTemplateService
.selectTitleAndContentByIdentification(ConstantUtil.E_FAULTREPORT);
Parkinglot parkinglot = vehicleService.selectByPrimaryKeyParkinglot(vehicle.getParkid());
CarManager carManager =carManagerService.selectByPrimaryKey(taskInfo.getTaskuserid());
String content = mTemplate.getContent().replaceAll("【plateNumber】", vehicle.getPlatenumber());
content = content.replaceAll("【name】", carManager.getName());
content = content.replaceAll("【phone】", carManager.getUsername());
if(mTemplate!=null)
{
PostMsgHttpContent.sendMessage(parkinglot.getTelephone(),content);
logger.info("<----------------故障完成发短信:短信发送成功" + "---------------------->");
}
else
{
logger.info("<----------------故障完成发短信:短信模板为空" + "---------------------->");
}
carManagerLogService.insertLog(taskInfo.getTaskuserid(), "上报故障,车牌号:" + vehicle.getPlatenumber());// +
// "
// 故障ID:"
// +
// faultReport.getId()
messageResult.setCode(ConstantUtil.M_SUCCESS);
messageResult.setMessage("故障上报成功");
this.out(response, messageResult);
} else {
messageResult.setCode(ConstantUtil.M_EXCEPTION);
messageResult.setMessage("故障上报失败了，请稍后再试");
this.out(response, messageResult);
}
}
} else {
messageResult.setCode(ConstantUtil.M_PARAMTER_NULL);
messageResult.setMessage("无任务信息");
this.out(response, messageResult);
}
}
}