Skip to content

G
gdtel-gztel-school-center
Commit ccb1ce23 by 董有沛
Options

解决冲突

parents 7fab82c0 484ee1e2
Showing with 3656 additions and 557 deletions
apply-net/pom.xml
......@@ -15,6 +15,11 @@
<dependencies>
<dependency>
<groupId>org.jsoup</groupId>
<artifactId>jsoup</artifactId>
<version>1.9.2</version>
</dependency>
<dependency>
<groupId>com.winsun.framework</groupId>
<artifactId>winsun-core-message</artifactId>
<version>${winsun-framework.version}</version>
......
apply-net/src/main/java/com/winsun/controller/DankuanController.java
package com.winsun.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.winsun.auth.core.common.model.ResponseData;
import com.winsun.bean.Product;
import com.winsun.bean.School;
import com.winsun.bean.UniversityInfo;
import com.winsun.bean.*;
import com.winsun.constant.Constant;
import com.winsun.constant.OrderStatus;
import com.winsun.mapper.*;
import com.winsun.utils.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* 单宽办理接口
*
* @Author xuede
* @Date 2020/3/9 16:52
* @Version 1.0
......@@ -26,60 +45,921 @@ import java.util.Map;
@RestController
@RequestMapping("/dankuan")
public class DankuanController {
@Autowired
private ProductMapper productMapper;
@Autowired
private SchoolMapper schoolMapper;
@Autowired
private UserSchoolMapper userSchoolMapper;
@Autowired
private AppMapper appMapper;
@Autowired
private UniversityInfoMapper universityInfoMapper;
@Autowired
private OrderViewMapper orderViewMapper;
@Autowired
private OrderMapper orderMapper;
@Autowired
private OrderHistoryMapper historyMapper;
@Autowired
private SysUserMapper sysUserMapper;
/**
* 查询单宽办理接口
*
* @return
*/
@RequestMapping("/data")
public ResponseData<Product> getdankuanData(@RequestParam("id") Integer id) {
//空，直接返回
if (id == null) {
return ResponseData.error("请输入合伙人id");
}
String schoolId = appMapper.selectSchoolId(id.toString());
School school = schoolMapper.selectById(schoolId);
String bandproductId = school.getBandproductId();
if (StringUtils.isBlank(bandproductId)) {
return ResponseData.error("敬请期待");
}
Product product = productMapper.selectById(bandproductId);
return ResponseData.success(product);
}
@RequestMapping("/selectUniversity")
public ResponseData<UniversityInfo> selectUniversity(@RequestParam("universityId") String universityId) {
UniversityInfo universityInfo = universityInfoMapper.selectById(universityId);
return ResponseData.success(universityInfo);
}
/**
* 创建单宽order_view
*
* @param orderName
* @param orderPhone
* @param orderNumber
* @param orderCustomerStudentId
* @param orderCustomerAccount
* @param orderCustomerPwd
* @param orderSetMeal
* @param productId
* @param webOrderAmount
* @param partner
* @return
* @throws Exception
*/
@RequestMapping("/createProductOrder")
public ResponseData<OrderView> createProductOrder(@RequestParam("orderName") String orderName, @RequestParam("orderPhone") String orderPhone,
@RequestParam("orderNumber") String orderNumber, @RequestParam("orderCustomerStudentId") String orderCustomerStudentId,
@RequestParam("orderCustomerAccount") String orderCustomerAccount, @RequestParam("orderCustomerPwd") String orderCustomerPwd,
@RequestParam("orderSetMeal") String orderSetMeal, @RequestParam("productId") String productId,
@RequestParam("webOrderAmount") String webOrderAmount, @RequestParam("partner") String partner) throws Exception {
if (!IDCardUtil.IDCardValidate(orderNumber)) {
return ResponseData.error("您的身份证输入有误，请重新输入！");
}
if (orderPhone.length() != 11) {
return ResponseData.error("联系号码有误，请重新输入");
}
Wrapper<OrderView> wrapper = new EntityWrapper<>();
wrapper.eq(StringUtils.isNotBlank(orderNumber), "orderNumber", orderNumber);
wrapper.ne("status", OrderStatus.INVALID.getId());
List<OrderView> orderViews = orderViewMapper.selectList(wrapper);
OrderView orderV = new OrderView();
if (orderViews.size() != 0) {
if (StringUtils.isNotBlank(orderViews.get(0).getUptranseq())) {
Wrapper<Order> wrapperO = new EntityWrapper<>();
wrapperO.eq("order_number", orderViews.get(0).getOrderSeq());
wrapperO.eq("user_type", "5");
List<Order> orders = orderMapper.selectList(wrapperO);
if (orders.size() == 0) {
return ResponseData.error("当前身份证号订单异常，请联系客服！");
}
orderV.setOrderSeq(orders.get(0).getId());
orderV.setUptranseq(orderViews.get(0).getUptranseq());
return ResponseData.error(orderV, "当前身份证号订单已存在并完成支付！");
}
if ("0".equals(orderViews.get(0).getWebOrderAmount())) {
Wrapper<Order> wrapperO = new EntityWrapper<>();
wrapperO.eq("order_number", orderViews.get(0).getOrderSeq());
wrapperO.eq("user_type", "5");
List<Order> orders = orderMapper.selectList(wrapperO);
if (orders.size() == 0) {
return ResponseData.error("当前身份证号订单异常，请联系客服！");
}
orderV.setOrderSeq(orders.get(0).getId());
orderV.setUptranseq(orderViews.get(0).getOrderId().toString());
return ResponseData.error(orderV, "当前身份证号订单已存在！");
}
orderV.setOrderId(orderViews.get(0).getOrderId());
orderV.setOrderSeq(orderViews.get(0).getOrderSeq());
return ResponseData.error(orderV, "当前身份证号已有订单存在！");
}
String orderSeq = "YRYM" + ProduceIdUtil.getId();
Product product = productMapper.selectById(productId);
OrderView orderView = new OrderView();
orderView.setOrderName(orderName);
orderView.setOrderPhone(orderPhone);
orderView.setOrderNumber(orderNumber);
orderView.setOrderCustomerStudentId(orderCustomerStudentId);
orderView.setOrderCustomerAccount(orderCustomerAccount);
orderView.setOrderCustomerPwd(orderCustomerPwd);
orderView.setOrderSetMeal(orderSetMeal);
orderView.setOrderSeq(orderSeq);
orderView.setProductName(product.getProductTitle());
orderView.setOrderDate(new Date());
orderView.setOrderUniversityName(product.getProductUniversity());
orderView.setStatus(OrderStatus.NOTPAID.getId());
orderView.setOrderRegion(product.getProductRegion());
orderView.setPayType("1");
orderView.setWebOrderAmount(webOrderAmount);
if (webOrderAmount.equals("0")) {
orderView.setIPay("0");
} else {
orderView.setIPay("1");
}
orderView.setCustomerId("xyzxyql");
orderView.setOrderCustomerType("学生");
Integer insert = orderViewMapper.insert(orderView);
if (webOrderAmount.equals("0")) {
ResponseData<OrderView> res = createOrder(orderView, partner, orderSeq);
if (!res.isSuccess()) {
return res;
}
}
if (insert == 1) {
orderV.setOrderId(orderView.getOrderId());
orderV.setOrderSeq(orderView.getOrderSeq());
return ResponseData.success(orderV, "订单提交完成！");
}
return ResponseData.error("提交失败！");
}
/**
* 0元调用 创建order
* @param orderView
* @param userId
* @param orderseq
* @return
* @throws Exception
*/
public ResponseData<OrderView> createOrder(OrderView orderView, String userId, String orderseq) throws Exception {
String uuid = UUID.randomUUID().toString();
String id = uuid.split("-")[0] + uuid.split("-")[1];
Order order = new Order();
order.setId(id);
order.setOrderNumber(orderView.getOrderSeq());
order.setOrderStatus(OrderStatus.NOTPAID.getName());
order.setHehuorenId(userId);
order.setCustomerName(orderView.getOrderName());
order.setContactNumber(orderView.getOrderPhone());
order.setIdCard(orderView.getOrderNumber());
order.setCreateTime(new Date());
order.setUserType("5");
order.setNetNumber(orderView.getOrderCustomerAccount());
order.setNetPassword(orderView.getOrderCustomerPwd());
order.setUserSchool(orderView.getOrderUniversityName());
order.setExpenses(orderView.getOrderSetMeal());
order.setKdOrderId(orderView.getOrderSeq());
SysUser sysUser = sysUserMapper.selectById(userId);
order.setHehuorenPhone(sysUser.getPhone());
String schoolId = appMapper.selectSchoolId(userId);
School school = schoolMapper.selectById(schoolId);
order.setHehuorenSchool(school.getSchoolName());
order.setHehuorenName(sysUser.getName());
order.setHehuorenArea(sysUser.getSubstName());
List<String> userId1 = appMapper.selectsupervisorBySchool(schoolId);
SysUser user = sysUserMapper.selectById(userId1.get(0));
order.setSupervisorName(user.getName());
order.setLzgh(school.getLzgh());
// 根据学校名称，获取该学校信息
Wrapper<UniversityInfo> wrapper1 = new EntityWrapper<>();
wrapper1.eq("university_name", orderView.getOrderUniversityName());
wrapper1.eq("university_region", orderView.getOrderRegion());
Map<String, Object> schoolMap = universityInfoMapper.selectMaps(wrapper1).get(0);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
String currentTimeStr = simpleDateFormat.format(new Date());
String productId = "519";
/* if (StringUtils.isBlank(orderView.getOrderseqthd())) {
JSONObject productJsonObject = getProductId(currentTimeStr);
if (productJsonObject.toString().indexOf("list") == -1) {
return ResponseData.error("未找到产品信息，如有疑问请联系客服！");
}
JSONArray list = productJsonObject.getJSONArray("list");
String productName = "校园宽带0元";
for (int i = 0; i < list.size(); i++) {
JSONObject itmeJson = JSONObject.parseObject(list.get(i).toString());
// 判断获取的全部产品与订单产品符合的拿取对应的ID
if (itmeJson.getString("name").indexOf(productName) != -1) {
productId = itmeJson.getString("id"); // 获取对应产品ID
break;
}
}
}*/
String saleId = "1475"; // 销售id
/* JSONObject saleJsonObject = getSaleId(productId, currentTimeStr); // 获取销售ID
log.info("----------调用智能平台的获取销售品接口返回值：" + saleJsonObject);
JSONArray saleList = saleJsonObject.getJSONArray("list");
JSONObject itmeJson = JSONObject.parseObject(saleList.get(0).toString());
saleId = itmeJson.getString("saleId");*/
JSONObject submitOrderJsonObject = getOrderInfo(schoolMap, orderView, currentTimeStr, productId, saleId, "", "", "", "");
String orderNum = (String) submitOrderJsonObject.get("orderNumber");
if (StringUtils.isNotBlank(orderNum)) {
Wrapper<OrderView> wrapper = new EntityWrapper<>();
wrapper.eq("orderSeq", orderseq);
Map<String, Object> dataMapping1 = new HashMap<>();
dataMapping1.put("orderSeqTHD", orderNum);
dataMapping1.put("status", "已支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping1), wrapper);
order.setOrderStatus("审核中");
order.setOrderId(orderNum);
order.setThStatus(submitOrderJsonObject.get("status").toString());
orderMapper.insert(order);
appMapper.inserOrderHis(id, "待审核！", new Date(), orderView.getOrderName());
} else {
return ResponseData.error("智能平台订单创建失败，如有疑问请联系客服！");
}
return ResponseData.success(orderView, "智能平台订单创建成功");
}
/**
* 支付完成回调接口
*
* @param request
* @throws Exception
*/
@RequestMapping(value = "toSubmisOrderPreser", method = {RequestMethod.GET, RequestMethod.POST}, produces = "text/plain;charset=UTF-8")
public void toSubmisOrderPreser(HttpServletRequest request) throws Exception {
OrderView orderMap = null;
Map<String, Object> schoolMap = null;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
String currentTimeStr = simpleDateFormat.format(new Date());
log.info("----------异步通知后返回入口----------");
String orderseq = request.getParameter("ORDERSEQ");//orderseq
String uptranseq = request.getParameter("UPTRANSEQ"); // 穗易付平台，支付流水号uptranseq
String orderamount = request.getParameter("ORDERAMOUNT");//orderamount 价格
String orderreqtranseq = request.getParameter("ORDERREQTRANSEQ"); // 穗易付订单号 orderreqtranseq
/*String orderseq = "4iz818f1u74kznypf3w81";
String uptranseq = "2019082922001464810523969803"; // 穗易付平台，支付流水号
String orderamount = "30";
String orderreqtranseq = "GZCTPAY20190829384046979"; // 穗易付订单号*/
log.info("----------异步请求接受参数订单号：" + orderseq);
log.info("----------异步请求接受参数支付流水号：" + uptranseq);
log.info("----------异步请求接受参数订单金额：" + orderamount);
log.info("----------异步请求接受参数穗易付订单号：" + orderreqtranseq);
Wrapper<OrderView> wrapper = new EntityWrapper<>();
wrapper.eq("orderSeq", orderseq);
Map<String, Object> dataMapping = new HashMap<>();
dataMapping.put("orderReqtranSeq", orderreqtranseq);
dataMapping.put("uptranseq", uptranseq);
dataMapping.put("order_payment_time", new Date());
dataMapping.put("status", "已支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping), wrapper);
wrapper.eq("orderSeq", orderseq);
orderMap = orderViewMapper.selectList(wrapper).get(0);
// 根据学校名称，获取该学校信息
Wrapper<UniversityInfo> wrapper1 = new EntityWrapper<>();
wrapper1.eq("university_name", orderMap.getOrderUniversityName());
wrapper1.eq("university_region", orderMap.getOrderRegion());
schoolMap = universityInfoMapper.selectMaps(wrapper1).get(0);
if (StringUtils.isBlank(orderMap.getOrderseqThd())) {
// 1、获取产品ID
JSONObject productJsonObject = getProductId(currentTimeStr);
log.info("----------调用智能平台的产品接口返回参数：" + productJsonObject);
// 2、获取销售品ID
if (productJsonObject.toString().indexOf("list") == -1) {
return;
}
JSONArray list = productJsonObject.getJSONArray("list");
String productId = null; // 产品id
orderamount = orderamount.replace("元", "");
orderamount = orderamount.replace(".00", "");
String productName = "校园宽带" + orderamount + "元";
if (orderamount.equals("0.01")) {
productName = "校园宽带30元";
} else if (orderamount.equals("0.02")) {
productName = "校园宽带300元";
}
log.info("------" + productName);
//productName = "校园宽带30元";
for (int i = 0; i < list.size(); i++) {
JSONObject itmeJson = JSONObject.parseObject(list.get(i).toString());
// 判断获取的全部产品与订单产品符合的拿取对应的ID
if (itmeJson.getString("name").indexOf(productName) != -1) {
productId = itmeJson.getString("id"); // 获取对应产品ID
break;
}
}
log.info("----------根据返回参数获取产品ID：" + productId);
String saleId = null; // 销售id
JSONObject saleJsonObject = getSaleId(productId, currentTimeStr); // 获取销售ID
log.info("----------调用智能平台的获取销售品接口返回值：" + saleJsonObject);
JSONArray saleList = saleJsonObject.getJSONArray("list");
JSONObject itmeJson = JSONObject.parseObject(saleList.get(0).toString());
saleId = itmeJson.getString("saleId");
// 3、提交订单到智能平台
JSONObject submitOrderJsonObject = getOrderInfo(schoolMap, orderMap, currentTimeStr, productId, saleId, orderseq, uptranseq, orderamount, orderreqtranseq);
log.info("----------调用单宽带接口（提交订单至智能平台）并返回参数信息---status:" + submitOrderJsonObject.get("status") + " msg:" + submitOrderJsonObject.get("msg") + " orderNum:" + submitOrderJsonObject.get("orderNumber"));
// 4、查询智能订单是否存在
String orderNum = (String) submitOrderJsonObject.get("orderNumber");
if (StringUtils.isNotBlank(orderNum)) {
/* 5、更新数据库 */
Map<String, Object> dataMapping1 = new HashMap<>();
dataMapping1.put("orderSeqTHD", orderNum);
dataMapping1.put("status", "已支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping1), wrapper);
Wrapper<Order> objectEntityWrapper = new EntityWrapper<>();
objectEntityWrapper.eq("order_number", orderseq);
Map<String, Object> dataMapping2 = new HashMap<>();
dataMapping2.put("order_status", "审核中");
dataMapping2.put("order_id", orderNum);
dataMapping2.put("th_status", submitOrderJsonObject.get("status"));
orderMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping2), objectEntityWrapper);
List<Order> orders = orderMapper.selectList(objectEntityWrapper);
appMapper.inserOrderHis(orders.get(0).getId(), "支付完成,待审核！", new Date(), orders.get(0).getCustomerName());
}
} else {
log.info("---单宽支付接口推送---" + orderseq + "---" + uptranseq + "---" + orderamount + "---" + orderreqtranseq);
}
}
/**
* 支付接口
*
* @param orderId
* @param ipay
* @param userId
* @param request
* @param response
* @return
* @throws Exception
*/
@RequestMapping(value = "orderPay", method = {RequestMethod.GET, RequestMethod.POST}, produces = "text/plain;charset=UTF-8")
@ResponseBody
public String toPaymentPlatformPage(@RequestParam("orderId") String orderId, @RequestParam("ipay") String ipay, @RequestParam("userId") String userId, HttpServletRequest request, HttpServletResponse response) throws Exception {
JsoupMethodZhifu(orderId, ipay, userId, request, response);
return null;
}
/**
* @author ljh
* @Description:支付请求
*/
public void JsoupMethodZhifu(String orderId, String ipay, String userId,
HttpServletRequest request, HttpServletResponse response) throws Exception {
log.info("----------首先发送支付请求接口----------");
//查询订单信息
OrderView orderView = orderViewMapper.selectById(orderId);
String uuid = UUID.randomUUID().toString();
String id = uuid.split("-")[0] + uuid.split("-")[1];
//修改支付方式
Wrapper<OrderView> wrapper = new EntityWrapper<>();
wrapper.eq("order_id", orderId);
Map<String, Object> dataMapping = new HashMap<>();
dataMapping.put("ipay", ipay);
Map<String, String> map = new HashMap<String, String>();
//给MAP数组添加数据
map.put("CLIENTNUMBER", Constant.CLIENTNUMBER);//商户标识，由穗易付平台统一分配
map.put("ORDERSEQ", orderView.getOrderSeq());//订单号
log.info("----------宽带价格prices：" + orderView.getWebOrderAmount());
if (Constant.PRODUCTSKU479Str.indexOf(orderView.getWebOrderAmount()) != -1) {
map.put("PRODUCTSKU", Constant.PRODUCTSKU479);//商户产品
} else {
map.put("PRODUCTSKU", Constant.PRODUCTSKU481);
}
Date orderdate = orderView.getOrderDate();
SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
map.put("ORDERDATE", ft.format(orderdate));
map.put("ORDERAMOUNT", orderView.getWebOrderAmount());//价格
map.put("ORDERNAME", orderView.getOrderName());//用户名
map.put("ORDERPHONE", orderView.getOrderPhone());//支付宝账号（电话）
map.put("ORDERNUMBER", orderView.getOrderNumber());//身份证
if (Constant.Payment1.equals(ipay)) {
//支付成功回调的页面
// String MERCHANTURL = Constant.TOMCATURL + "/dankuan/toPaymentSuccessPage?id=" + userId +"orderId="+id;
String MERCHANTURL = "https://www.baidu.com";
map.put("MERCHANTURL", MERCHANTURL);
}
//单宽回调后端接口地址
// map.put("BACKDROPURL", Constant.TOMCATURL + "/dankuan/toSubmisOrderPreser");
map.put("BACKDROPURL", "http://yrym.winsun-aly.com/gdtel-xyzx-hhr/paymentCon/toSubmisOrderPreser.do");
String str = "ORDERSEQ=" + orderView.getOrderSeq() + "&ORDERDATE=" + ft.format(orderdate) + "&ORDERAMOUNT=" + orderView.getWebOrderAmount() + "&KEY=" + Constant.KEY;//商户标识
//* 将值转换为大写 *//*
map.put("MAC", MD5Utils.md5(str).toUpperCase());
int PAYTYPE = 1; // 支付类型
int IPAY = 1; // 支付平台
log.info("----------支付渠道（0翼支付网厅，1支付宝，3微信）：" + ipay);
if (Constant.Payment3.equals(ipay)) {
PAYTYPE = 5;
IPAY = 3;
}
map.put("PAYTYPE", String.valueOf(PAYTYPE));
map.put("IPAY", String.valueOf(IPAY));
log.info("----------支付请求参数：" + map);
//定义Document对象
Document doc = null;
String result = "";
String qrcode = "";
//Jsoup用post提交,超时6秒钟，
doc = Jsoup.connect("https://gzdxpay.mini189.cn/web/order-pay.action").data(map).timeout(20000).ignoreContentType(true).post();
//获取回调信息
String i = doc.text().trim();
log.info(i);
//解析json格式
JSONObject json = JSONObject.parseObject(i);
//获取jsonp格式中的result（短链接，返回到前端）
log.info("----------调用穗易付接口返回的结果：" + json);
result = (String) json.get("result");
qrcode = (String) json.get("qrcode");
String ORDERSEQ = (String) json.get("ORDERSEQ");
String msg = (String) json.get("msg");
if (StringUtils.isNotBlank(msg) && msg.equals("success")) {
dataMapping.put("status", "未支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping), wrapper);
Order order = new Order();
order.setId(id);
order.setOrderNumber(orderView.getOrderSeq());
order.setOrderStatus(OrderStatus.NOTPAID.getName());
order.setHehuorenId(userId);
order.setCustomerName(orderView.getOrderName());
order.setContactNumber(orderView.getOrderPhone());
order.setIdCard(orderView.getOrderNumber());
order.setCreateTime(new Date());
order.setUserType("5");
order.setNetNumber(orderView.getOrderCustomerAccount());
order.setNetPassword(orderView.getOrderCustomerPwd());
order.setUserSchool(orderView.getOrderUniversityName());
order.setExpenses(orderView.getOrderSetMeal());
order.setKdOrderId(orderView.getOrderSeq());
SysUser sysUser = sysUserMapper.selectById(userId);
order.setHehuorenPhone(sysUser.getPhone());
String schoolId = appMapper.selectSchoolId(userId);
School school = schoolMapper.selectById(schoolId);
order.setHehuorenSchool(school.getSchoolName());
order.setHehuorenName(sysUser.getName());
order.setHehuorenArea(sysUser.getSubstName());
List<String> userId1 = appMapper.selectsupervisorBySchool(schoolId);
SysUser user = sysUserMapper.selectById(userId1.get(0));
order.setSupervisorName(user.getName());
order.setLzgh(school.getLzgh());
orderMapper.insert(order);
appMapper.inserOrderHis(id, "支付请求提交！", new Date(), orderView.getOrderName());
response.sendRedirect(result);
}
}
/**
* @author ljh
* @Description:获取产品ID
* @method:getProductId
* @return: JSONObject
* @date 2018年6月5日上午10:21:19
* @version 1.0
* @exception:
*/
private static JSONObject getProductId(String currentTimeStr) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
Map<String, String> signMap = new HashMap<String, String>();//待签名参数
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(50000)
.setConnectTimeout(50000).setConnectionRequestTimeout(50000).build();
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "query.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
qParams.add(new BasicNameValuePair("service", "product.broadband.query"));//api标识，必填
signMap.put("service", "product.broadband.query");
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));//时间戳（YYYYMMDDHHMMSS） ，必填
signMap.put("timeStamp", currentTimeStr);
qParams.add(new BasicNameValuePair("business", "单宽带"));//产品类型，必填
signMap.put("business", "单宽带");
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);//key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
resultDataJson = JSONObject.parseObject(httpResult);
} catch (Exception e) {
log.info("查询单宽带(预付费、移动、融合、续约、增值)产品接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
/**
* @author ljh
* @Description:获取销售品ID
* @method:getSaleId
* @return: JSONObject
* @date 2018年6月5日上午10:23:42
* @version 1.0
* @exception:
*/
/**
* 单宽支付平台异步更新后台地址，主要对订单进去保存和提交订单到智能平台上
*/
@RequestMapping(value = "getSaleId", method = {RequestMethod.GET, RequestMethod.POST}, produces = "text/plain;charset=UTF-8")
private static JSONObject getSaleId(String productId, String currentTimeStr) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
Map<String, String> signMap = new HashMap<String, String>();//待签名参数
HttpHost proxy = new HttpHost("172.18.101.170", 3128);
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(500000)
.setConnectTimeout(500000).setConnectionRequestTimeout(500000).setProxy(proxy).build();
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "query.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
qParams.add(new BasicNameValuePair("service", "sale.query"));//api标识，必填
signMap.put("service", "sale.query");
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));
signMap.put("timeStamp", currentTimeStr);
if (StringUtils.isNotBlank(productId)) {
qParams.add(new BasicNameValuePair("productId", productId));//产品ID
signMap.put("productId", productId);
}
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);//key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
log.info("返回信息:" + httpResult);
resultDataJson = JSONObject.parseObject(httpResult);
} catch (Exception e) {
log.info("---接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
/**
* @author ljh
* @Description:提交单宽
* @method:getOrderInfo
* @return: JSONObject
* @date 2018年6月5日上午10:41:21
* @version 1.0
* @exception:
*/
private static JSONObject getOrderInfo(Map<String, Object> schoolMap, OrderView orderMap, String currentTimeStr, String productId, String saleId, String ORDERSEQ, String UPTRANSEQ, String ORDERAMOUNT, String ORDERREQTRANSEQ) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(50000)
.setConnectTimeout(50000).setConnectionRequestTimeout(50000).build();
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "create-order.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
Map<String, String> signMap = new HashMap<String, String>();//待签名参数
qParams.add(new BasicNameValuePair("service", "order.broadband.create"));//api标识，必填
signMap.put("service", "order.broadband.create"); //api标识，必填
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));//时间戳（YYYYMMDDHHMMSS） ，必填
signMap.put("timeStamp", currentTimeStr);
qParams.add(new BasicNameValuePair("productCategory", "单宽带"));//业务类型 ，必填
signMap.put("productCategory", "单宽带");
qParams.add(new BasicNameValuePair("customerType", "2")); //客户类型 （1：已有固话，未有宽带 2：未有固话和宽带），必填
signMap.put("customerType", "2");
qParams.add(new BasicNameValuePair("fixedPhoneNum", "")); //客户类型为1时，固话号码，必填
signMap.put("fixedPhoneNum", "");
qParams.add(new BasicNameValuePair("govEntCustomer", "0")); //是否政企客户下单 0：否 1：是，必填
signMap.put("govEntCustomer", "0");
qParams.add(new BasicNameValuePair("agentName", "")); //若是政企客户下单，代办人姓名，必填
signMap.put("agentName", "");
qParams.add(new BasicNameValuePair("agentCardNum", "")); //若是政企客户下单，代办人身份证号码，必填
signMap.put("agentCardNum", "");
qParams.add(new BasicNameValuePair("customerName", orderMap.getOrderName())); //客户姓名，必填
signMap.put("customerName", orderMap.getOrderName());
qParams.add(new BasicNameValuePair("customerPhone", orderMap.getOrderPhone())); //客户电话，必填
signMap.put("customerPhone", orderMap.getOrderPhone());
qParams.add(new BasicNameValuePair("customerCardType", "身份证")); //证件类型，必填
signMap.put("customerCardType", "身份证");
qParams.add(new BasicNameValuePair("customerCardNum", orderMap.getOrderNumber())); //证件号码，必填
signMap.put("customerCardNum", orderMap.getOrderNumber());
qParams.add(new BasicNameValuePair("addressProvince", "广东省")); //报装地址省份，必填
signMap.put("addressProvince", "广东省");
qParams.add(new BasicNameValuePair("addressCity", "广州市")); //报装地址城市，必填
signMap.put("addressCity", "广州市");
qParams.add(new BasicNameValuePair("deliveryProvince", "广东省"));// 配送地址-省，必填
signMap.put("deliveryProvince", "广东省");
qParams.add(new BasicNameValuePair("deliveryCity", "广州市"));// 配送地址-市，必填
signMap.put("deliveryCity", "广州市");
String addressDistrict = null;
String address = null;
String addressID = null;
String landId = null;
String universityTerminalType = null;
String universityUserCategory = null;
String universityUserType = null;
String universityMonthlyRentType = null;
String universityChargingAttribute = null;
String universityOnlineNumber = null;
String universityOneManTerminal = null;
String universityIsFtthHub = null;
String universityExteriorLines = null;
String universityChargeMode = null;
if (BeanUtil.isNotBlank(schoolMap)) {
addressDistrict = (String) schoolMap.get("universityRegion");
address = (String) schoolMap.get("universityInstalledAddress");
addressID = (String) schoolMap.get("universityInstalledAddressId");
landId = (String) schoolMap.get("universityPackageNumber");
universityTerminalType = (String) schoolMap.get("universityTerminalType");
universityUserCategory = (String) schoolMap.get("universityUserCategory");
universityUserType = (String) schoolMap.get("universityUserType");
universityMonthlyRentType = (String) schoolMap.get("universityMonthlyRentType");
universityChargingAttribute = (String) schoolMap.get("universityChargingAttribute");
universityOnlineNumber = (String) schoolMap.get("universityOnlineNumber");
universityOneManTerminal = (String) schoolMap.get("universityOneManTerminal");
universityIsFtthHub = (String) schoolMap.get("universityIsFtthHub");
universityExteriorLines = (String) schoolMap.get("universityExteriorLines");
universityChargeMode = (String) schoolMap.get("universityChargeMode");
} else {
addressDistrict = "测试区";
address = "广东省广州市测试区测试街道1号";
addressID = "00000";
landId = "20180621";
universityTerminalType = "测试";
universityUserCategory = "测试";
universityUserType = "测试";
universityMonthlyRentType = "测试";
universityChargingAttribute = "测试";
universityOnlineNumber = "0";
universityOneManTerminal = "否";
universityIsFtthHub = "否";
universityExteriorLines = "测试";
universityChargeMode = "测试";
}
qParams.add(new BasicNameValuePair("addressDistrict", addressDistrict)); //报装地址区域，必填
signMap.put("addressDistrict", addressDistrict);
qParams.add(new BasicNameValuePair("address", address)); //报装详细地址，必填
signMap.put("address", address);
qParams.add(new BasicNameValuePair("deliveryDistrict", addressDistrict));// 配送地址-区，必填
signMap.put("deliveryDistrict", addressDistrict);
qParams.add(new BasicNameValuePair("deliveryAddress", address));// 配送地址-详细地址，必填
signMap.put("deliveryAddress", address);
qParams.add(new BasicNameValuePair("deliveryContact", orderMap.getOrderName())); //报装联系人，必填
signMap.put("deliveryContact", orderMap.getOrderName());
qParams.add(new BasicNameValuePair("deliveryContactPhone", orderMap.getOrderPhone())); //报装联系电话，必填
signMap.put("deliveryContactPhone", orderMap.getOrderPhone());
qParams.add(new BasicNameValuePair("invoiced", "0")); //是否需要发票 0：否 1：是，必填
signMap.put("invoiced", "0");
qParams.add(new BasicNameValuePair("invoiceTitle", "")); //若需要发票，发票抬头，必填
signMap.put("invoiceTitle", "");
qParams.add(new BasicNameValuePair("invoiceDeliveryAddress", "")); //若需要发票，发票电子邮箱，必填
signMap.put("invoiceDeliveryAddress", "");
qParams.add(new BasicNameValuePair("landId", landId)); //揽装工号，必填
signMap.put("landId", landId);
qParams.add(new BasicNameValuePair("groupLanId", "")); //集团揽装工号，选填
signMap.put("groupLanId", "");
qParams.add(new BasicNameValuePair("comarketingLanId", "")); //协销工号，选填
signMap.put("comarketingLanId", "");
qParams.add(new BasicNameValuePair("groupComarketingLanId", "")); //集团协销工号，选填
signMap.put("groupComarketingLanId", "");
qParams.add(new BasicNameValuePair("orderOutNum", orderMap.getOrderSeq())); //外部订单编号，选填!；通过API接口下单，必须传入一个外部接入商的订单编号,该编号与智能营销系统编号一一对应
signMap.put("orderOutNum", orderMap.getOrderSeq());
qParams.add(new BasicNameValuePair("orderSource", "校园宽带自助受理")); //订单来源 ，选填
signMap.put("orderSource", "校园宽带自助受理");
qParams.add(new BasicNameValuePair("orderSourceNum", orderMap.getOrderSeq())); //订单来源单号，选填； 与订单来源对应，用于业务上记录订单的来源订单编号
signMap.put("orderSourceNum", orderMap.getOrderSeq());
qParams.add(new BasicNameValuePair("salePointCode", "")); //销售点编码，选填
signMap.put("salePointCode", "");
qParams.add(new BasicNameValuePair("personCode", "")); //人员编码，选填
signMap.put("personCode", "");
qParams.add(new BasicNameValuePair("distributorSmsReceive", "")); //分销商短信接收号码，选填
signMap.put("distributorSmsReceive", "");
qParams.add(new BasicNameValuePair("agent", "")); //代理商推荐人，选填
signMap.put("agent", "");
qParams.add(new BasicNameValuePair("copyied", "0")); //是否收取复印件(0:否 1:是),必填
signMap.put("copyied", "0");
qParams.add(new BasicNameValuePair("deliveryContactPhone", orderMap.getOrderPhone())); //联系人电话 ，必填
signMap.put("deliveryContactPhone", orderMap.getOrderPhone());
qParams.add(new BasicNameValuePair("deliveryContactPhone2", "")); //联系人电话2，选填
signMap.put("deliveryContactPhone2", "");
List<Map<String, Object>> productList = new ArrayList<Map<String, Object>>();//下单产品列表
List<Map<String, String>> paymentList = new ArrayList<Map<String, String>>();//收费项列表
List<Map<String, String>> propertyList = new ArrayList<Map<String, String>>();//产品自定义属性列表
//下单产品
Map<String, Object> productMap = new HashMap<String, Object>();
//收费项；智能平台3.0产品设计中收费项可由用户自主选择（至少选择一个），可根据需要创建paymentMap对象；注意：每个收费项可独立选择缴费方式
Map<String, String> paymentMap = new HashMap<String, String>();
paymentMap.put("id", saleId);//收费项ID，必填；请通过销售品列表接口获取
paymentMap.put("payType", "2");//缴费方式，必填（例：payType：1）；1：银行划账2：现金支付3：代理商打款4：穗易付5：原套餐缴费方式6：支付宝划扣8：装维上门收取
paymentMap.put("tag", "");//费用项标识，选填
paymentMap.put("bank", "");//缴费银行，缴费方式为“银行划账”时必填 ：[中国银行|中国工商银行|中国农业银行|民生银行|招商银行|中信银行|商业银行|广东发展银行|光大银行|华夏银行|兴业银行|浦发银行|广州农村商业银行|广州银行|深圳发展银行|交通银行|中国建设银行|邮政储蓄]
paymentMap.put("bankNumber", "");//银行账号，缴费方式为“银行划账”时必填
paymentMap.put("bankOwner", "");////银行账号持有人，缴费方式为“银行划账”时必填
String payPlatform = orderMap.getIPay();
if (StringUtils.isNotBlank(payPlatform)) {
if ("1".equals(payPlatform)) {
paymentMap.put("payPlatform", "支付宝");//支付平台，缴费方式为“穗易付”时必填
} else {
paymentMap.put("payPlatform", "微信");//支付平台，缴费方式为“穗易付”时必填
}
} else {
paymentMap.put("payPlatform", "穗易付");//支付平台，缴费方式为“穗易付”时必填
}
if (StringUtils.isNotBlank(UPTRANSEQ)) {
paymentMap.put("electronicPayNumber", UPTRANSEQ);//支付流水号，缴费方式为“穗易付”时必填
} else {
paymentMap.put("electronicPayNumber", "");//支付流水号，缴费方式为“穗易付”时必填
}
if (StringUtils.isNotBlank(ORDERREQTRANSEQ)) {
paymentMap.put("payOrderNumber", ORDERREQTRANSEQ);// 穗易付订单号，若选择穗易付，此项必填
} else {
paymentMap.put("payOrderNumber", "");// 穗易付订单号，若选择穗易付，此项必填
}
if (StringUtils.isNotBlank(ORDERAMOUNT)) {
paymentMap.put("payAmount", ORDERAMOUNT);//缴费金额（打款金额），缴费方式为“代理商打款”或“穗易付”时必填
} else {
paymentMap.put("payAmount", "");//缴费金额（打款金额），缴费方式为“代理商打款”或“穗易付”时必填
}
paymentMap.put("alipayUserid", "");//用户ID，缴费方式为“支付宝支付”时必填
paymentMap.put("alipayNumber", "");//支付宝账号，缴费方式为“支付宝支付”时必填
paymentMap.put("alipayAuthNumber", "");//授权协议号，缴费方式为“支付宝支付”时必填
paymentList.add(paymentMap);
//产品自定义属性；暂时默认属性名称只能传“日租卡号码”
Map<String, String> propertyMap = new HashMap<String, String>();
propertyMap.put("name", "宽带速率");
String setMeal = orderMap.getOrderSetMeal();
if (StringUtils.isNotBlank(setMeal)) {
setMeal = setMeal.replace("包月", "");
setMeal = setMeal.replace("包年", "");
}
if (setMeal.contains("20M")) {
setMeal = "20M下行速率/4M上行速率";
} else if (setMeal.contains("2M")) {
setMeal = "2M下行速率/512K上行速率";
} else if (setMeal.contains("50M")) {
setMeal = "50M下行速率/10M上行速率";
}
propertyMap.put("value", setMeal);
Map<String, String> propertyMap1 = new HashMap<String, String>();
propertyMap1.put("name", "学校名称");
propertyMap1.put("value", orderMap.getOrderUniversityName());
Map<String, String> propertyMap2 = new HashMap<String, String>();
propertyMap2.put("name", "允许上网终端类型");
propertyMap2.put("value", universityTerminalType);
Map<String, String> propertyMap3 = new HashMap<String, String>();
propertyMap3.put("name", "用户类别");
propertyMap3.put("value", universityUserCategory);
Map<String, String> propertyMap4 = new HashMap<String, String>();
propertyMap4.put("name", "用户类型");
propertyMap4.put("value", universityUserType);
Map<String, String> propertyMap5 = new HashMap<String, String>();
propertyMap5.put("name", "月租类型");
propertyMap5.put("value", universityMonthlyRentType);
Map<String, String> propertyMap6 = new HashMap<String, String>();
propertyMap6.put("name", "计费属性");
propertyMap6.put("value", universityChargingAttribute);
Map<String, String> propertyMap7 = new HashMap<String, String>();
propertyMap7.put("name", "一人一号多终端");
propertyMap7.put("value", universityOneManTerminal);
Map<String, String> propertyMap8 = new HashMap<String, String>();
propertyMap8.put("name", "外线方式");
propertyMap8.put("value", universityExteriorLines);
Map<String, String> propertyMap9 = new HashMap<String, String>();
propertyMap9.put("name", "是否FTTH+HUB");
propertyMap9.put("value", universityIsFtthHub);
Map<String, String> propertyMap10 = new HashMap<String, String>();
propertyMap10.put("name", "多媒体账号");
propertyMap10.put("value", orderMap.getOrderCustomerAccount());
Map<String, String> propertyMap11 = new HashMap<String, String>();
propertyMap11.put("name", "多媒体账号密码");
propertyMap11.put("value", orderMap.getOrderCustomerPwd());
Map<String, String> propertyMap12 = new HashMap<String, String>();
propertyMap12.put("name", "学生证号");
propertyMap12.put("value", orderMap.getOrderCustomerStudentId());
Map<String, String> propertyMap13 = new HashMap<String, String>();
propertyMap13.put("name", "宽带首月费用类型");
propertyMap13.put("value", universityChargeMode);
Map<String, String> propertyMap14 = new HashMap<String, String>();
propertyMap14.put("name", "最大在线数");
propertyMap14.put("value", universityOnlineNumber);
Map<String, String> propertyMap15 = new HashMap<String, String>();
propertyMap15.put("name", "地址ID");
propertyMap15.put("value", addressID);
propertyList.add(propertyMap);
propertyList.add(propertyMap1);
propertyList.add(propertyMap2);
propertyList.add(propertyMap3);
propertyList.add(propertyMap4);
propertyList.add(propertyMap5);
propertyList.add(propertyMap6);
propertyList.add(propertyMap7);
propertyList.add(propertyMap8);
propertyList.add(propertyMap9);
propertyList.add(propertyMap10);
propertyList.add(propertyMap11);
propertyList.add(propertyMap12);
propertyList.add(propertyMap13);
propertyList.add(propertyMap14);
propertyList.add(propertyMap15);
productMap.put("productId", productId);//产品ID，请通过产品列表接口获取
productMap.put("payment", paymentList);//收费项列表
productMap.put("addProperties", propertyList);//产品自定义属性列表
productList.add(productMap);
//将对象装换为json字符串
String productJson = JSONArray.toJSONString(productList);
qParams.add(new BasicNameValuePair("productJson", URLEncoder.encode(productJson, "UTF-8")));//产品信息，必填
signMap.put("productJson", URLEncoder.encode(productJson, "UTF-8"));
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);//key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
log.info("单宽带下单接口，返回信息:" + httpResult);
resultDataJson = JSONObject.parseObject(httpResult);
} catch (Exception e) {
log.info("单宽带下单接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
private static ProductMapper productMapper;
private static SchoolMapper schoolMapper;
private static AppMapper appMapper;
private static UniversityInfoMapper universityInfoMapper;
@Autowired
public DankuanController(ProductMapper productMapper,SchoolMapper schoolMapper,AppMapper appMapper,UniversityInfoMapper universityInfoMapper ){
DankuanController.productMapper=productMapper;
DankuanController.schoolMapper=schoolMapper;
DankuanController.appMapper=appMapper;
DankuanController.universityInfoMapper=universityInfoMapper;
}
/**
* 查询单宽办理接口
* @return
*/
@RequestMapping("/data")
public ResponseData<Product> getdankuanData(@RequestParam("id") Integer id){
//空，直接返回
if (id==null){
return ResponseData.error("请输入合伙人id");
}
String schoolId = appMapper.selectSchoolId(id.toString());
School school = schoolMapper.selectById(schoolId);
String bandproductId = school.getBandproductId();
if (StringUtils.isBlank(bandproductId)){
return ResponseData.error("敬请期待");
}
Product product = productMapper.selectById(bandproductId);
return ResponseData.success(product);
}
@RequestMapping("/DomainName")
public ResponseData<String> getDomainName(@RequestParam("schoolName") String schoolName){
//空，直接返回
if (StringUtils.isBlank(schoolName)){
return ResponseData.error("请输入学校名称");
}
EntityWrapper<UniversityInfo> universityInfowrapper = new EntityWrapper<>();
universityInfowrapper.setSqlSelect("university_domain_name as domainName",schoolName);
universityInfowrapper.eq("university_name",schoolName);
List<Map<String,Object>> universityInfos = universityInfoMapper.selectMaps(universityInfowrapper);
if (CollectionUtils.isEmpty(universityInfos)){
return ResponseData.error("查找不到学校相应数据");
}
if ( universityInfos.get(0).get("domainName")==null){
return ResponseData.error("查找不到学校相应数据");
}
return ResponseData.success(universityInfos.get(0).get("domainName").toString());
}
}
apply-net/src/main/java/com/winsun/controller/RongHeController.java 0 → 100644
package com.winsun.controller;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.winsun.auth.core.common.model.ResponseData;
import com.winsun.bean.*;
import com.winsun.constant.Constant;
import com.winsun.constant.OrderStatus;
import com.winsun.mapper.*;
import com.winsun.smsUtils.SendSmsAndMail;
import com.winsun.utils.BeanUtil;
import com.winsun.utils.MD5Utils;
import com.winsun.utils.MyBatisPlusUpdateUtils;
import com.winsun.utils.ProduceIdUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* 单宽办理接口
*
* @Author xuede
* @Date 2020/3/9 16:52
* @Version 1.0
*/
@Slf4j
@RestController
@RequestMapping("/rongHe")
public class RongHeController {
@Autowired
private ProductMapper productMapper;
@Autowired
private SchoolMapper schoolMapper;
@Autowired
private UserSchoolMapper userSchoolMapper;
@Autowired
private AppMapper appMapper;
@Autowired
private UniversityInfoMapper universityInfoMapper;
@Autowired
private OrderViewMapper orderViewMapper;
@Autowired
private OrderMapper orderMapper;
@Autowired
private OrderHistoryMapper historyMapper;
@Autowired
private SysUserMapper sysUserMapper;
private static String verifyCode = "";
@ResponseBody
@RequestMapping(value = "rhSendCodes", method = RequestMethod.POST)
public ResponseData<Map<String, Object>> rhSendCodes(String phone,HttpServletRequest request) {
Map<String, Object> map = new HashMap<>();
HttpSession session = request.getSession();
//随机生成六位数字验证码
String vCode = String.valueOf((int) (Math.random() * 900000 + 100000));
//第一次发送验证码
session.setAttribute("currentDate", System.currentTimeMillis());//Session放入当前系统时间
long currentDate = (Long) session.getAttribute("currentDate");
Long date = (Long) session.getAttribute("date");
//12小时内若发送验证码，currentDate的值则变成当前系统时间替换第一次发送验证码存入的时间，
// 并获取第一次的date相减，两次验证码发送时间相隔不超过一分钟，不允许持续发送
if (date != null && currentDate - date < 1000 * 60 * 60 * 12) {
map.put("errorState", "验证码发送未超过12小时");
map.put("verifyCode", session.getAttribute("verifyCode"));
return ResponseData.success(map);
}
session.setAttribute("date", System.currentTimeMillis());//Session放入当前系统时间
session.setAttribute("phoneNum", phone);//Session放入手机号码
session.setAttribute("verifyCode", vCode);//Session放入验证码
if("".equals(verifyCode)){
SendSmsAndMail.sendSms(phone,vCode+"","7");
verifyCode = vCode;
}
log.info(verifyCode);
map.put("verifyCode", verifyCode);
map.put("success", "验证码已发送");
return ResponseData.success(map);
}
/**
* 跟据合伙人id查找融合套餐信息
*
* @param hhrId
* @return
*/
@RequestMapping("/rhData")
public ResponseData<Map<String, Object>> getRhData(@RequestParam("hhrId") String hhrId) {
//空，直接返回
if (StringUtils.isEmpty(hhrId)) {
return ResponseData.error("请输入合伙人id");
}
UserSchool userSchool = userSchoolMapper.selectById(hhrId);
School school = schoolMapper.selectById(userSchool.getSchoolId());
String bandproductId = school.getBandproductId();
if (StringUtils.isBlank(bandproductId)) {
return ResponseData.error("敬请期待");
}
Product product = productMapper.selectById(bandproductId);
UniversityInfo universityInfo = universityInfoMapper.selectById(product.getUniversityId());
Map<String, Object> objMap = new HashMap<>();
objMap.put("product", product);
objMap.put("universityInfo", universityInfo);
return ResponseData.success(objMap);
}
/**
* 支付平台异步更新后台地址，主要对订单进去保存和提交订单到智能平台上
* @return
* @throws Exception
*/
@RequestMapping("/createRongHeOrder")
public ResponseData<OrderView> createRongHeOrder(
@RequestParam("orderName") String orderName, @RequestParam("orderPhone") String orderPhone,
@RequestParam("orderNumber") String orderNumber, @RequestParam("orderCustomerStudentId") String orderCustomerStudentId,
@RequestParam("orderCustomerAccount") String orderCustomerAccount, @RequestParam("orderCustomerPwd") String orderCustomerPwd,
@RequestParam("orderSetMeal") String orderSetMeal, @RequestParam("productId") String productId,
@RequestParam("webOrderAmount") String webOrderAmount, @RequestParam("partner") String partner,
@RequestParam("banLiPhone") String banLiPhone ) throws Exception {
Wrapper<OrderView> orderViewWrapper = new EntityWrapper<>();
orderViewWrapper.eq(StringUtils.isNotBlank(orderNumber), "orderNumber", orderNumber);
orderViewWrapper.ne("status", OrderStatus.INVALID.getId());
List<OrderView> orderViews = orderViewMapper.selectList(orderViewWrapper);
OrderView orderV = new OrderView();
if (orderViews.size() != 0) {
if (StringUtils.isNotBlank(orderViews.get(0).getUptranseq())) {
Wrapper<Order> wrapperO = new EntityWrapper<>();
wrapperO.eq("order_number", orderViews.get(0).getOrderSeq());
wrapperO.eq("user_type", "5");
List<Order> orders = orderMapper.selectList(wrapperO);
if (orders.size() == 0) {
return ResponseData.error("当前身份证号订单异常，请联系客服！");
}
orderV.setOrderSeq(orders.get(0).getId());
orderV.setUptranseq(orderViews.get(0).getUptranseq());
return ResponseData.error(orderV, "当前身份证号订单已存在并完成支付！");
}
if ("0".equals(orderViews.get(0).getWebOrderAmount())) {
Wrapper<Order> wrapperO = new EntityWrapper<>();
wrapperO.eq("order_number", orderViews.get(0).getOrderSeq());
wrapperO.eq("user_type", "5");
List<Order> orders = orderMapper.selectList(wrapperO);
if (orders.size() == 0) {
return ResponseData.error("当前身份证号订单异常，请联系客服！");
}
orderV.setOrderSeq(orders.get(0).getId());
orderV.setUptranseq(orderViews.get(0).getOrderId().toString());
return ResponseData.error(orderV, "当前身份证号订单已存在！");
}
orderV.setOrderId(orderViews.get(0).getOrderId());
orderV.setOrderSeq(orderViews.get(0).getOrderSeq());
return ResponseData.error(orderV, "当前身份证号已有订单存在！");
}
String orderSeq = "YRYM" + ProduceIdUtil.getId();
Product product = productMapper.selectById(productId);
OrderView orderView = new OrderView();
orderView.setOrderSeq(orderSeq); // 订单号码
orderView.setOrderName(orderName); // 姓名
orderView.setOrderPhone(orderPhone); // 联系电话
orderView.setOrderNumber(orderNumber); // 身份证号码
orderView.setOrderCustomerStudentId(orderCustomerStudentId);// 学生证号
orderView.setOrderCustomerAccount(orderCustomerAccount);// 多媒体账号
orderView.setOrderCustomerPwd(orderCustomerPwd);// 多媒体密码
orderView.setOrderSetMeal(orderSetMeal);// 套餐
orderView.setProductName(product.getProductTitle());// 产品名称
orderView.setOrderDate(new Date()); // 提交时间
orderView.setOrderUniversityName(product.getProductUniversity()); // 学校
orderView.setStatus(OrderStatus.NOTPAID.getId());
orderView.setOrderRegion(product.getProductRegion()); // 区域
orderView.setPayType("1"); // 支付方式
orderView.setWebOrderAmount(webOrderAmount); // 产品价格
if (webOrderAmount.equals("0")) {
orderView.setIPay("0"); // 支付平台
} else {
orderView.setIPay("1"); // 支付平台
}
orderView.setCustomerId("xyzxyql"); // 接入商
orderView.setOrderCustomerType("学生"); // 用户类别
Integer insert = orderViewMapper.insert(orderView);
if (webOrderAmount.equals("0")) {
ResponseData<OrderView> res = createOrder(productId,orderView, partner, orderSeq);
if (!res.isSuccess()) {
return res;
}
}
if (insert == 1) {
Wrapper<OrderView> ovWrapper = new EntityWrapper<>();
ovWrapper.eq(StringUtils.isNotBlank(orderNumber), "orderNumber", orderNumber);
ovWrapper.eq("orderSeq", orderSeq);
List<OrderView> list = orderViewMapper.selectList(ovWrapper);
orderV.setOrderId(list.get(0).getOrderId());
orderV.setOrderSeq(orderSeq);
return ResponseData.success(orderV, "订单提交完成！");
}
return ResponseData.error("提交失败！");
}
public ResponseData<OrderView> createOrder(String productId,OrderView orderView, String userId, String orderseq) throws Exception {
String uuid = UUID.randomUUID().toString();
String id = uuid.split("-")[0] + uuid.split("-")[1];
Order order = new Order();
order.setId(id);
order.setOrderNumber(orderView.getOrderSeq());
order.setOrderStatus(OrderStatus.NOTPAID.getName());
order.setHehuorenId(userId);
order.setCustomerName(orderView.getOrderName());
order.setContactNumber(orderView.getOrderPhone());
order.setIdCard(orderView.getOrderNumber());
order.setCreateTime(new Date());
order.setUserType("5");
order.setNetNumber(orderView.getOrderCustomerAccount());
order.setNetPassword(orderView.getOrderCustomerPwd());
order.setUserSchool(orderView.getOrderUniversityName());
order.setExpenses(orderView.getOrderSetMeal());
order.setKdOrderId(orderView.getOrderSeq());
SysUser sysUser = sysUserMapper.selectById(userId);
order.setHehuorenPhone(sysUser.getPhone());
String schoolId = appMapper.selectSchoolId(userId);
School school = schoolMapper.selectById(schoolId);
order.setHehuorenSchool(school.getSchoolName());
order.setHehuorenName(sysUser.getName());
order.setHehuorenArea(sysUser.getSubstName());
/* List<String> userId1 = appMapper.selectsupervisorBySchool(schoolId);
SysUser user = sysUserMapper.selectById(userId1.get(0));
order.setSupervisorName(user.getName());
order.setLzgh(school.getLzgh());*/
// 根据订单号，获取该订单信息
// 根据学校名称，获取该学校信息
Product product = productMapper.selectById(productId);
Wrapper<UniversityInfo> uiWrapper = new EntityWrapper<>();
uiWrapper.eq("university_id",product.getUniversityId());
List<Map<String, Object>> list1 = universityInfoMapper.selectMaps(uiWrapper);
Map<String, Object> schoolMap = list1.get(0);
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
String currentTimeStr = simpleDateFormat.format(new Date());
//单宽带
String saleId1 = "4907";
//提速包
String saleId2 = null;
String productName = "校园融合套餐";
log.info("----------根据返回参数获取产品ID：" + productId);
String saleId = null; // 销售id
JSONObject saleJsonObject = getSaleId(productId, currentTimeStr); // 获取销售ID
log.info("----------调用智能平台的获取销售品接口返回值：" + saleJsonObject);
log.info("----111--" + (saleJsonObject.toString().indexOf("list") == -1));
if (saleJsonObject.toString().indexOf("list") == -1) {
return ResponseData.error("没有找到销售品接口返回值");
}
String expenses = "";
if (schoolMap.get("identifying") != null) {
expenses = schoolMap.get("identifying").toString();
}
JSONArray saleList = saleJsonObject.getJSONArray("list");
log.info("----saleList---：" + saleList);
for (int i = 0; i < saleList.size(); i++) {
JSONObject itmeJson = saleList.getJSONObject(i);
// 判断获取的全部产品与订单产品符合的拿取对应的ID
if (itmeJson.getString("propertyName").indexOf("提速包") != -1) {
if (itmeJson.getString("name").equals(expenses)) {
// 获取对应产品ID
saleId2 = itmeJson.getString("saleId");
}
} else if (itmeJson.getString("propertyName").indexOf("增值业务") != -1) {
if (itmeJson.getString("name").equals(expenses)) {
// 获取对应产品ID
saleId2 = itmeJson.getString("saleId");
}
}
}
JSONObject submitOrderJsonObject = getOrderInfo(schoolMap, orderView, currentTimeStr, productId, saleId1,saleId2, "", "", "", "");
String orderNum = (String) submitOrderJsonObject.get("orderNumber");
if (StringUtils.isNotBlank(orderNum)) {
Wrapper<OrderView> wrapper = new EntityWrapper<>();
wrapper.eq("orderSeq", orderseq);
Map<String, Object> dataMapping1 = new HashMap<>();
dataMapping1.put("orderSeqTHD", orderNum);
dataMapping1.put("status", "已支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping1), wrapper);
order.setOrderStatus("审核中");
order.setOrderId(orderNum);
order.setThStatus(submitOrderJsonObject.get("status").toString());
orderMapper.insert(order);
appMapper.inserOrderHis(id, "待审核！", new Date(), orderView.getOrderName());
} else {
return ResponseData.error("智能平台订单创建失败，如有疑问请联系客服！");
}
return ResponseData.success(orderView, "智能平台订单创建成功");
}
@RequestMapping(value = "toSubmisOrderPreser", method = {RequestMethod.GET, RequestMethod.POST}, produces = "text/plain;charset=UTF-8")
public void toSubmisOrderPreser(HttpServletRequest request) throws Exception {
OrderView orderMap = null;
Map<String, Object> schoolMap = null;
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
String currentTimeStr = simpleDateFormat.format(new Date());
log.info("----------异步通知后返回入口----------");
String orderseq = request.getParameter("ORDERSEQ");//orderseq
String uptranseq = request.getParameter("UPTRANSEQ"); // 穗易付平台，支付流水号uptranseq
String orderamount = request.getParameter("ORDERAMOUNT");//orderamount 价格
String orderreqtranseq = request.getParameter("ORDERREQTRANSEQ"); // 穗易付订单号 orderreqtranseq
/*String orderseq = "4iz818f1u74kznypf3w81";
String uptranseq = "2019082922001464810523969803"; // 穗易付平台，支付流水号
String orderamount = "30";
String orderreqtranseq = "GZCTPAY20190829384046979"; // 穗易付订单号*/
log.info("----------异步请求接受参数订单号：" + orderseq);
log.info("----------异步请求接受参数支付流水号：" + uptranseq);
log.info("----------异步请求接受参数订单金额：" + orderamount);
log.info("----------异步请求接受参数穗易付订单号：" + orderreqtranseq);
Wrapper<OrderView> wrapper = new EntityWrapper<>();
wrapper.eq("orderSeq", orderseq);
Map<String, Object> dataMapping = new HashMap<>();
dataMapping.put("orderReqtranSeq", orderreqtranseq);
dataMapping.put("uptranseq", uptranseq);
dataMapping.put("order_payment_time", new Date());
dataMapping.put("status", "已支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping), wrapper);
wrapper.eq("orderSeq", orderseq);
orderMap = orderViewMapper.selectList(wrapper).get(0);
// 根据学校名称，获取该学校信息
Wrapper<UniversityInfo> wrapper1 = new EntityWrapper<>();
wrapper1.eq("university_name", orderMap.getOrderUniversityName());
wrapper1.eq("university_region", orderMap.getOrderRegion());
schoolMap = universityInfoMapper.selectMaps(wrapper1).get(0);
if (StringUtils.isBlank(orderMap.getOrderseqThd())) {
// 1、获取产品ID
JSONObject productJsonObject = getProductId(currentTimeStr);
log.info("----------调用智能平台的产品接口返回参数：" + productJsonObject);
// 2、获取销售品ID
if (productJsonObject.toString().indexOf("list") == -1) {
return;
}
JSONArray list = productJsonObject.getJSONArray("list");
String productId = null; // 产品id
orderamount = orderamount.replace("元", "");
orderamount = orderamount.replace(".00", "");
String productName = "校园宽带" + orderamount + "元";
if (orderamount.equals("0.01")) {
productName = "校园宽带30元";
} else if (orderamount.equals("0.02")) {
productName = "校园宽带300元";
}
log.info("------" + productName);
//productName = "校园宽带30元";
for (int i = 0; i < list.size(); i++) {
JSONObject itmeJson = JSONObject.parseObject(list.get(i).toString());
// 判断获取的全部产品与订单产品符合的拿取对应的ID
if (itmeJson.getString("name").indexOf(productName) != -1) {
productId = itmeJson.getString("id"); // 获取对应产品ID
break;
}
}
log.info("----------根据返回参数获取产品ID：" + productId);
String saleId = null; // 销售id
JSONObject saleJsonObject = getSaleId(productId, currentTimeStr); // 获取销售ID
log.info("----------调用智能平台的获取销售品接口返回值：" + saleJsonObject);
JSONArray saleList = saleJsonObject.getJSONArray("list");
JSONObject itmeJson = JSONObject.parseObject(saleList.get(0).toString());
saleId = itmeJson.getString("saleId");
// 3、提交订单到智能平台
JSONObject submitOrderJsonObject = getOrderInfo(schoolMap, orderMap, currentTimeStr, productId, saleId,"", orderseq, uptranseq, orderamount, orderreqtranseq);
log.info("----------调用单宽带接口（提交订单至智能平台）并返回参数信息---status:" + submitOrderJsonObject.get("status") + " msg:" + submitOrderJsonObject.get("msg") + " orderNum:" + submitOrderJsonObject.get("orderNumber"));
// 4、查询智能订单是否存在
String orderNum = (String) submitOrderJsonObject.get("orderNumber");
if (StringUtils.isNotBlank(orderNum)) {
/* 5、更新数据库 */
Map<String, Object> dataMapping1 = new HashMap<>();
dataMapping1.put("orderSeqTHD", orderNum);
dataMapping1.put("status", "已支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping1), wrapper);
Wrapper<Order> objectEntityWrapper = new EntityWrapper<>();
objectEntityWrapper.eq("order_number", orderseq);
Map<String, Object> dataMapping2 = new HashMap<>();
dataMapping2.put("order_status", "审核中");
dataMapping2.put("order_id", orderNum);
dataMapping2.put("th_status", submitOrderJsonObject.get("status"));
orderMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping2), objectEntityWrapper);
List<Order> orders = orderMapper.selectList(objectEntityWrapper);
appMapper.inserOrderHis(orders.get(0).getId(), "支付完成,待审核！", new Date(), orders.get(0).getCustomerName());
}
} else {
log.info("---单宽支付接口推送---" + orderseq + "---" + uptranseq + "---" + orderamount + "---" + orderreqtranseq);
}
}
@RequestMapping(value = "orderPay", method = {RequestMethod.GET, RequestMethod.POST}, produces = "text/plain;charset=UTF-8")
@ResponseBody
public String toPaymentPlatformPage(@RequestParam("orderId") String orderId, @RequestParam("ipay") String ipay, @RequestParam("userId") String userId, HttpServletRequest request, HttpServletResponse response) throws Exception {
JsoupMethodZhifu(orderId, ipay, userId, request, response);
return null;
}
/**
* @author ljh
* @Description:支付请求
*/
public void JsoupMethodZhifu(String orderId, String ipay, String userId,
HttpServletRequest request, HttpServletResponse response) throws Exception {
log.info("----------首先发送支付请求接口----------");
//查询订单信息
OrderView orderView = orderViewMapper.selectById(orderId);
String uuid = UUID.randomUUID().toString();
String id = uuid.split("-")[0] + uuid.split("-")[1];
//修改支付方式
Wrapper<OrderView> wrapper = new EntityWrapper<>();
wrapper.eq("order_id", orderId);
Map<String, Object> dataMapping = new HashMap<>();
dataMapping.put("ipay", ipay);
Map<String, String> map = new HashMap<String, String>();
//给MAP数组添加数据
map.put("CLIENTNUMBER", Constant.CLIENTNUMBER);//商户标识，由穗易付平台统一分配
map.put("ORDERSEQ", orderView.getOrderSeq());//订单号
log.info("----------宽带价格prices：" + orderView.getWebOrderAmount());
if (Constant.PRODUCTSKU479Str.indexOf(orderView.getWebOrderAmount()) != -1) {
map.put("PRODUCTSKU", Constant.PRODUCTSKU479);//商户产品
} else {
map.put("PRODUCTSKU", Constant.PRODUCTSKU481);
}
Date orderdate = orderView.getOrderDate();
SimpleDateFormat ft = new SimpleDateFormat("yyyyMMdd");
map.put("ORDERDATE", ft.format(orderdate));
map.put("ORDERAMOUNT", orderView.getWebOrderAmount());//价格
map.put("ORDERNAME", orderView.getOrderName());//用户名
map.put("ORDERPHONE", orderView.getOrderPhone());//支付宝账号（电话）
map.put("ORDERNUMBER", orderView.getOrderNumber());//身份证
if (Constant.Payment1.equals(ipay)) {
//支付成功回调的页面
// String MERCHANTURL = Constant.TOMCATURL + "/dankuan/toPaymentSuccessPage?id=" + userId +"orderId="+id;
String MERCHANTURL = "https://www.baidu.com";
map.put("MERCHANTURL", MERCHANTURL);
}
//单宽回调后端接口地址
// map.put("BACKDROPURL", Constant.TOMCATURL + "/dankuan/toSubmisOrderPreser");
map.put("BACKDROPURL", "http://yrym.winsun-aly.com/gdtel-xyzx-hhr/paymentCon/toSubmisOrderPreser.do");
String str = "ORDERSEQ=" + orderView.getOrderSeq() + "&ORDERDATE=" + ft.format(orderdate) + "&ORDERAMOUNT=" + orderView.getWebOrderAmount() + "&KEY=" + Constant.KEY;//商户标识
//* 将值转换为大写 *//*
map.put("MAC", MD5Utils.md5(str).toUpperCase());
int PAYTYPE = 1; // 支付类型
int IPAY = 1; // 支付平台
log.info("----------支付渠道（0翼支付网厅，1支付宝，3微信）：" + ipay);
if (Constant.Payment3.equals(ipay)) {
PAYTYPE = 5;
IPAY = 3;
}
map.put("PAYTYPE", String.valueOf(PAYTYPE));
map.put("IPAY", String.valueOf(IPAY));
log.info("----------支付请求参数：" + map);
//定义Document对象
Document doc = null;
String result = "";
String qrcode = "";
//Jsoup用post提交,超时6秒钟，
doc = Jsoup.connect("https://gzdxpay.mini189.cn/web/order-pay.action").data(map).timeout(20000).ignoreContentType(true).post();
//获取回调信息
String i = doc.text().trim();
log.info(i);
//解析json格式
JSONObject json = JSONObject.parseObject(i);
//获取jsonp格式中的result（短链接，返回到前端）
log.info("----------调用穗易付接口返回的结果：" + json);
result = (String) json.get("result");
qrcode = (String) json.get("qrcode");
String ORDERSEQ = (String) json.get("ORDERSEQ");
String msg = (String) json.get("msg");
if (StringUtils.isNotBlank(msg) && msg.equals("success")) {
dataMapping.put("status", "未支付");
orderViewMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping), wrapper);
Order order = new Order();
order.setId(id);
order.setOrderNumber(orderView.getOrderSeq());
order.setOrderStatus(OrderStatus.NOTPAID.getName());
order.setHehuorenId(userId);
order.setCustomerName(orderView.getOrderName());
order.setContactNumber(orderView.getOrderPhone());
order.setIdCard(orderView.getOrderNumber());
order.setCreateTime(new Date());
order.setUserType("5");
order.setNetNumber(orderView.getOrderCustomerAccount());
order.setNetPassword(orderView.getOrderCustomerPwd());
order.setUserSchool(orderView.getOrderUniversityName());
order.setExpenses(orderView.getOrderSetMeal());
order.setKdOrderId(orderView.getOrderSeq());
SysUser sysUser = sysUserMapper.selectById(userId);
order.setHehuorenPhone(sysUser.getPhone());
String schoolId = appMapper.selectSchoolId(userId);
School school = schoolMapper.selectById(schoolId);
order.setHehuorenSchool(school.getSchoolName());
order.setHehuorenName(sysUser.getName());
order.setHehuorenArea(sysUser.getSubstName());
List<String> userId1 = appMapper.selectsupervisorBySchool(schoolId);
SysUser user = sysUserMapper.selectById(userId1.get(0));
order.setSupervisorName(user.getName());
order.setLzgh(school.getLzgh());
orderMapper.insert(order);
appMapper.inserOrderHis(id, "支付请求提交！", new Date(), orderView.getOrderName());
response.sendRedirect(result);
}
}
/**
* @author ljh
* @Description:获取产品ID
* @method:getProductId
* @return: JSONObject
* @date 2018年6月5日上午10:21:19
* @version 1.0
* @exception:
*/
private static JSONObject getProductId(String currentTimeStr) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
Map<String, String> signMap = new HashMap<String, String>();//待签名参数
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(50000)
.setConnectTimeout(50000).setConnectionRequestTimeout(50000).build();
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "query.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
qParams.add(new BasicNameValuePair("service", "product.broadband.query"));//api标识，必填
signMap.put("service", "product.broadband.query");
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));//时间戳（YYYYMMDDHHMMSS） ，必填
signMap.put("timeStamp", currentTimeStr);
qParams.add(new BasicNameValuePair("business", "单宽带"));//产品类型，必填
signMap.put("business", "单宽带");
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);//key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
resultDataJson = JSONObject.parseObject(httpResult);
} catch (Exception e) {
log.info("查询单宽带(预付费、移动、融合、续约、增值)产品接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
/**
* @author ljh
* @Description:获取销售品ID
* @method:getSaleId
* @return: JSONObject
* @date 2018年6月5日上午10:23:42
* @version 1.0
* @exception:
*/
/**
* 单宽支付平台异步更新后台地址，主要对订单进去保存和提交订单到智能平台上
*/
@RequestMapping(value = "getSaleId", method = {RequestMethod.GET, RequestMethod.POST}, produces = "text/plain;charset=UTF-8")
private static JSONObject getSaleId(String productId, String currentTimeStr) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
Map<String, String> signMap = new HashMap<String, String>();//待签名参数
HttpHost proxy = new HttpHost("172.18.101.170", 3128);
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(500000)
.setConnectTimeout(500000).setConnectionRequestTimeout(500000).setProxy(proxy).build();
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "query.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
qParams.add(new BasicNameValuePair("service", "sale.query"));//api标识，必填
signMap.put("service", "sale.query");
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));
signMap.put("timeStamp", currentTimeStr);
if (StringUtils.isNotBlank(productId)) {
qParams.add(new BasicNameValuePair("productId", productId));//产品ID
signMap.put("productId", productId);
}
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);//key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
log.info("返回信息:" + httpResult);
resultDataJson = JSONObject.parseObject(httpResult);
} catch (Exception e) {
log.info("---接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
/**
* @author ljh
* @Description:提交单宽
* @method:getOrderInfo
* @return: JSONObject
* @date 2018年6月5日上午10:41:21
* @version 1.0
* @exception:
*/
private static JSONObject getOrderInfo(Map<String, Object> schoolMap, OrderView orderView, String currentTimeStr, String productId, String saleId1, String saleId2, String ORDERSEQ, String UPTRANSEQ, String ORDERAMOUNT, String ORDERREQTRANSEQ) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
HttpHost proxy = new HttpHost("172.18.101.170", 3128);
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(500000)
.setConnectTimeout(500000).setConnectionRequestTimeout(500000).setProxy(proxy).build();
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "create-order.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
Map<String, String> signMap = new HashMap<String, String>();
qParams.add(new BasicNameValuePair("service", "order.combined.create"));// api标识，必填且唯一
signMap.put("service", "order.combined.create");
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));//时间戳（YYYYMMDDHHMMSS） ，必填
signMap.put("timeStamp", currentTimeStr);
qParams.add(new BasicNameValuePair("productCategory", "融合产品"));// 业务类型，必填且唯一
signMap.put("productCategory", "融合产品");
qParams.add(new BasicNameValuePair("transactType", "新宽旧移"));// 办理类型，必填[新宽新移][新宽旧移][旧宽新移][旧宽旧移]
signMap.put("transactType", "新宽旧移");
/* */
qParams.add(new BasicNameValuePair("ctNumber", orderView.getOrderPhone()));// 电信号码，办理类型，若选择[新宽旧移]或[旧宽旧移]，此项必填
signMap.put("ctNumber", orderView.getOrderPhone());
/* */
qParams.add(new BasicNameValuePair("addressProvince", "广东省"));// 报装地址-省 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("addressProvince", "广东省");
qParams.add(new BasicNameValuePair("addressCity", "广州市"));// 报装地址-市 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("addressCity", "广州市");
String addressDistrict = null;
String address = null;
String addressID = null;
String landId = null;
String universityTerminalType = null;
String universityUserCategory = null;
String universityUserType = null;
String universityMonthlyRentType = null;
String universityChargingAttribute = null;
String universityOnlineNumber = null;
String universityOneManTerminal = null;
String universityIsFtthHub = null;
String universityExteriorLines = null;
String universityChargeMode = null;
if (BeanUtil.isNotBlank(schoolMap)) {
addressDistrict = (String) schoolMap.get("universityRegion");
address = (String) schoolMap.get("universityInstalledAddress");
addressID = (String) schoolMap.get("universityInstalledAddressId");
landId = (String) schoolMap.get("universityPackageNumber");
universityTerminalType = (String) schoolMap.get("universityTerminalType");
universityUserCategory = (String) schoolMap.get("universityUserCategory");
universityUserType = (String) schoolMap.get("universityUserType");
universityMonthlyRentType = (String) schoolMap.get("universityMonthlyRentType");
universityChargingAttribute = (String) schoolMap.get("universityChargingAttribute");
universityOnlineNumber = (String) schoolMap.get("universityOnlineNumber");
universityOneManTerminal = (String) schoolMap.get("universityOneManTerminal");
universityIsFtthHub = (String) schoolMap.get("universityIsFtthHub");
universityExteriorLines = (String) schoolMap.get("universityExteriorLines");
universityChargeMode = (String) schoolMap.get("university_charge_mode");
} else {
addressDistrict = "测试区";
address = "广东省广州市测试区测试街道1号";
addressID = "00000";
landId = "20180621";
universityTerminalType = "测试";
universityUserCategory = "测试";
universityUserType = "测试";
universityMonthlyRentType = "测试";
universityChargingAttribute = "测试";
universityOnlineNumber = "0";
universityOneManTerminal = "否";
universityIsFtthHub = "否";
universityExteriorLines = "测试";
universityChargeMode = "测试";
}
qParams.add(new BasicNameValuePair("addressDistrict", addressDistrict));// 报装地址-区 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("addressDistrict", addressDistrict);
qParams.add(new BasicNameValuePair("address", address));// 报装地址-详细地址 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("address", address);
qParams.add(new BasicNameValuePair("addressId", addressID));// 报装地址-地址ID，选填
signMap.put("addressId", addressID);
qParams.add(new BasicNameValuePair("govEntCustomer", "0"));//是否政企客户下单 0：否 1：是，必填
signMap.put("govEntCustomer", "0");
qParams.add(new BasicNameValuePair("agentName", ""));//若是政企客户下单，代办人姓名，必填
signMap.put("agentName", "");
qParams.add(new BasicNameValuePair("agentCardNum", ""));//若是政企客户下单，代办人身份证号码，必填
signMap.put("agentCardNum", "");
qParams.add(new BasicNameValuePair("customerName", orderView.getOrderName()));// 客户姓名，必填
signMap.put("customerName", orderView.getOrderName());
qParams.add(new BasicNameValuePair("customerPhone", orderView.getOrderPhone()));// 客户电话|代办人电话，必填
signMap.put("customerPhone", orderView.getOrderPhone());
qParams.add(new BasicNameValuePair("customerCardType", "身份证"));// 证件类型，必填且只能为身份证
signMap.put("customerCardType", "身份证");
qParams.add(new BasicNameValuePair("customerCardNum", orderView.getOrderNumber()));// 证件号码，必填
signMap.put("customerCardNum", orderView.getOrderNumber());
qParams.add(new BasicNameValuePair("landId", landId));// 揽装工号，必填
signMap.put("landId", landId);
qParams.add(new BasicNameValuePair("comarketingLanId", ""));// 协销工号，选填
signMap.put("comarketingLanId", "");
qParams.add(new BasicNameValuePair("groupComarketingLanId", ""));//集团协销工号，选填
signMap.put("groupComarketingLanId", "");
qParams.add(new BasicNameValuePair("orderOutNum", ORDERSEQ));//外部订单编号，选填!；
//通过API接口下单，必须传入一个外部接入商的订单编号,该编号与智能营销系统编号一一对应
signMap.put("orderOutNum", ORDERSEQ);
qParams.add(new BasicNameValuePair("orderSource", "校园宽带自助受理"));// 订单来源 ，选填
signMap.put("orderSource", "校园宽带自助受理");
qParams.add(new BasicNameValuePair("orderSourceNum", ORDERSEQ));// 订单来源单号，选填；与订单来源对应，用于业务上记录订单的来源订单编号
signMap.put("orderSourceNum", ORDERSEQ);
qParams.add(new BasicNameValuePair("salePointCode", ""));// 销售点编码，选填
signMap.put("salePointCode", "");
qParams.add(new BasicNameValuePair("personCode", ""));// 人员编码，必填
signMap.put("personCode", "");
qParams.add(new BasicNameValuePair("deliveryProvince", "广东省"));// 配送地址-省，必填
signMap.put("deliveryProvince", "广东省");
qParams.add(new BasicNameValuePair("deliveryCity", "广州市"));// 配送地址-市，必填
signMap.put("deliveryCity", "广州市");
qParams.add(new BasicNameValuePair("deliveryDistrict", addressDistrict));// 配送地址-区，必填
signMap.put("deliveryDistrict", addressDistrict);
qParams.add(new BasicNameValuePair("deliveryAddress", address));// 配送地址-详细地址，必填
signMap.put("deliveryAddress", address);
qParams.add(new BasicNameValuePair("deliveryContact", orderView.getOrderName()));// 联系人，必填
signMap.put("deliveryContact", orderView.getOrderNumber());
qParams.add(new BasicNameValuePair("deliveryContactPhone", orderView.getOrderName()));// 联系电话，必填
signMap.put("deliveryContactPhone", orderView.getOrderName());
qParams.add(new BasicNameValuePair("deliveryContactPhone2", ""));// 联系电话2，选填
signMap.put("deliveryContactPhone2", "");
qParams.add(new BasicNameValuePair("invoiced", "0"));// 是否需要发票，必填
// 0:不需要；1:一次性发票；2:分月发票
signMap.put("invoiced", "0");
qParams.add(new BasicNameValuePair("invoiceTitle", ""));// 发票抬头，若需要发票必填
signMap.put("invoiceTitle", "");
qParams.add(new BasicNameValuePair("invoiceDeliveryAddress", ""));// 电子邮箱，若需要发票必填
signMap.put("invoiceDeliveryAddress", "");
qParams.add(new BasicNameValuePair("deliveryType", "不需配送"));// 发货类型，必填，填写[同德仓发货][不需配送][代理商自行发货]
signMap.put("deliveryType", "不需配送");
qParams.add(new BasicNameValuePair("deliveryCompany", ""));// 配送公司，选填，同德仓发货必填；填写只能填顺丰速运或者如风达或者京东快递或者EMS
signMap.put("deliveryCompany", "");
qParams.add(new BasicNameValuePair("gift", ""));// 礼品，选填，请通过礼品列表接口获取
signMap.put("gift", "");
qParams.add(new BasicNameValuePair("giftNum", ""));// 礼品数量，选填，若礼品填写则必填且为正整数
signMap.put("giftNum", "");
qParams.add(new BasicNameValuePair("acceptPriority", "7"));//受理优先级 为0-10范围内的整数! 选填
signMap.put("acceptPriority", "7");
List<Map<String, Object>> productList = new ArrayList<Map<String, Object>>();// 产品信息
List<Map<String, Object>> inPropertyList = new ArrayList<Map<String, Object>>();// 产品属性
List<Map<String, Object>> paymentList = new ArrayList<Map<String, Object>>();// 销售品信息(费用项)
List<Map<String, Object>> addPropertyList = new ArrayList<Map<String, Object>>();// 自定义产品属性
// 下单产品
Map<String, Object> productMap = new HashMap<String, Object>();
// 产品(一个订单只能有一种产品且数量为1)
productMap.put("productId", productId);// 产品id,必填，请通过产品列表接口获取
// 产品都必须传一个产品对应的唯一的收费项
Map<String, Object> paymentListMap = new HashMap<String, Object>();
paymentListMap.put("id", "4455");// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap.put("saleName", "校园融合套餐");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap.put("payType", "2");// 缴费方式，
//必填（例：payType：3）1：银行划账2：现金支付3：代理商打款4：穗易付6：支付宝划扣7：货到付款8：装维上门收取9:第三方托收11：代理商代扣
//单宽带
Map<String, Object> paymentListMap2 = new HashMap<String, Object>();
paymentListMap2.put("id", saleId1);// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap2.put("saleName", "");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap2.put("payType", "2");// 缴费方式，必填（例：payType：3）3：代理商打款4：穗易付7：货到付款
paymentListMap2.put("payAmount", ORDERAMOUNT);// 打款金额（支付金额），若选择代理商打款、者穗易付、货到付款，此项必填
String payPlatform = orderView.getIPay();
if (StringUtils.isNotBlank(payPlatform)) {
if ("1".equals(payPlatform)) {
paymentListMap2.put("payPlatform", "支付宝");//支付平台，缴费方式为“穗易付”时必填
} else {
paymentListMap2.put("payPlatform", "微信");//支付平台，缴费方式为“穗易付”时必填
}
} else {
paymentListMap2.put("payPlatform", "穗易付");//支付平台，缴费方式为“穗易付”时必填
}
paymentListMap2.put("electronicPayNumber", UPTRANSEQ);// 支付流水号，若选择穗易付，此项必填
paymentListMap2.put("payOrderNumber", ORDERREQTRANSEQ);// 穗易付订单号，若选择穗易付，此项必填
//提速包
Map<String, Object> paymentListMap3 = new HashMap<String, Object>();
paymentListMap3.put("id", saleId2);// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap3.put("saleName", "");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap3.put("saleAmount", "");// 售价，选填
paymentListMap3.put("payType", "2");// 缴费方式，必填（例：payType：3）3：代理商打款4：穗易付7：货到付款
paymentListMap3.put("payAmount", "0");// 打款金额（支付金额），若选择代理商打款、者穗易付、货到付款，此项必填
paymentList.add(paymentListMap);
paymentList.add(paymentListMap2);
paymentList.add(paymentListMap3);
productMap.put("payment", paymentList);
// 产品属性 必填主卡号码属性,name=主卡号码,value=11位数字或者随机；
Map<String, Object> inPropertyListMap = new HashMap<String, Object>();
inPropertyListMap.put("name", "主卡号码");
inPropertyListMap.put("value", orderView.getOrderPhone());
inPropertyList.add(inPropertyListMap);
productMap.put("inpProperties", inPropertyList);
Map<String, Object> propertyMap = new HashMap<String, Object>();
propertyMap.put("name", "宽带速率");
String setMeal = orderView.getOrderSetMeal();
if (StringUtils.isNotBlank(setMeal)) {
setMeal = setMeal.replace("包月", "");
setMeal = setMeal.replace("包年", "");
}
propertyMap.put("value", setMeal);
Map<String, Object> propertyMap1 = new HashMap<String, Object>();
propertyMap1.put("name", "学校名称");
propertyMap1.put("value", orderView.getOrderUniversityName());
Map<String, Object> propertyMap2 = new HashMap<String, Object>();
propertyMap2.put("name", "允许上网终端类型");
propertyMap2.put("value", universityTerminalType);
Map<String, Object> propertyMap3 = new HashMap<String, Object>();
propertyMap3.put("name", "用户类别");
propertyMap3.put("value", universityUserCategory);
Map<String, Object> propertyMap4 = new HashMap<String, Object>();
propertyMap4.put("name", "用户类型");
propertyMap4.put("value", universityUserType);
Map<String, Object> propertyMap5 = new HashMap<String, Object>();
propertyMap5.put("name", "月租类型");
propertyMap5.put("value", universityMonthlyRentType);
Map<String, Object> propertyMap6 = new HashMap<String, Object>();
propertyMap6.put("name", "计费属性");
propertyMap6.put("value", universityChargingAttribute);
Map<String, Object> propertyMap7 = new HashMap<String, Object>();
propertyMap7.put("name", "一人一号多终端");
propertyMap7.put("value", universityOneManTerminal);
Map<String, Object> propertyMap8 = new HashMap<String, Object>();
propertyMap8.put("name", "外线方式");
propertyMap8.put("value", universityExteriorLines);
Map<String, Object> propertyMap9 = new HashMap<String, Object>();
propertyMap9.put("name", "是否FTTH+HUB");
propertyMap9.put("value", universityIsFtthHub);
Map<String, Object> propertyMap16 = new HashMap<String, Object>();
propertyMap16.put("name", "宽带提速速率");
propertyMap16.put("value", schoolMap.get("speed"));
Map<String, Object> propertyMap10 = new HashMap<String, Object>();
propertyMap10.put("name", "多媒体账号");
propertyMap10.put("value", orderView.getOrderCustomerAccount());
Map<String, Object> propertyMap11 = new HashMap<String, Object>();
propertyMap11.put("name", "多媒体账号密码");
propertyMap11.put("value", orderView.getOrderCustomerPwd());
Map<String, Object> propertyMap12 = new HashMap<String, Object>();
propertyMap12.put("name", "学生证号");
propertyMap12.put("value", orderView.getOrderCustomerStudentId());
Map<String, Object> propertyMap13 = new HashMap<String, Object>();
propertyMap13.put("name", "宽带首月费用类型");
propertyMap13.put("value", universityChargeMode);
Map<String, Object> propertyMap14 = new HashMap<String, Object>();
propertyMap14.put("name", "最大在线数");
propertyMap14.put("value", universityOnlineNumber);
Map<String, Object> propertyMap15 = new HashMap<String, Object>();
propertyMap15.put("name", "地址ID");
propertyMap15.put("value", addressID);
addPropertyList.add(propertyMap);
addPropertyList.add(propertyMap1);
addPropertyList.add(propertyMap2);
addPropertyList.add(propertyMap3);
addPropertyList.add(propertyMap4);
addPropertyList.add(propertyMap5);
addPropertyList.add(propertyMap6);
addPropertyList.add(propertyMap7);
addPropertyList.add(propertyMap8);
addPropertyList.add(propertyMap9);
addPropertyList.add(propertyMap10);
addPropertyList.add(propertyMap11);
addPropertyList.add(propertyMap12);
addPropertyList.add(propertyMap13);
addPropertyList.add(propertyMap14);
addPropertyList.add(propertyMap15);
addPropertyList.add(propertyMap16);
productMap.put("addProperties", addPropertyList);
productList.add(productMap);
// 将对象装换为json字符串
String productJson = JSONObject.toJSONString(productList);
try {
qParams.add(new BasicNameValuePair("productJson", URLEncoder.encode(productJson, "UTF-8")));// 产品信息，必填
signMap.put("productJson", URLEncoder.encode(productJson, "UTF-8"));
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);// key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
log.info("---------plaintext---------:" + plaintext);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
log.info("---------sign---------:" + sign );
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
log.info("融合下单接口，返回信息:" + httpResult);
resultDataJson = JSONObject.parseObject(httpResult);
} catch (Exception e) {
System.out.println("融合下单接口接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
}
common/src/main/java/com/winsun/bean/Constant.java 0 → 100644
package com.winsun.bean;
/**
* @author ljh
* @Description:常量类
* @Title: Constant
* @date 2018年5月16日下午6:55:54
* @version 1.0
*/
public class Constant {
/* 默认一页显示10条数据 */
public final static Integer PAGENUM = 2;
/* 默认第一页 */
public final static Integer FROMPAGE = 0;
/*用户状态*/
public final static String USERQIDONG = "1";//启用
public final static String USERJINYONG = "0";//禁用
/*支付参数*/
public final static String CLIENTNUMBER = "xyzxyql"; //商户标识，由穗易付平台统一分配
public final static String KEY = "E805F0305C455BA7C5BAE3796C6500BD"; //商户标识，由穗易付平台统一分配
public final static String USERNAME = "apitest"; //智能平台提供测试的账号
public final static String USERNAMEKEY = "46b97294d4dac3f62ee42f3ab2804f68"; //智能平台提供的测试key
public final static String ZHENGSHIAUCCON = "ruany"; //智能平台提供的正式账号
public final static String ZHANGSHIKEY = "3df143292455bfea88bc613c53004d36"; //智能平台提供的正式key
// public final static String ZHENGSHIAUCCON = "xiaoykd"; //智能平台提供的正式账号
// public final static String ZHANGSHIKEY = "d345040accff0421d03f760a03e5cbd9"; //智能平台提供的正式key
public final static String ZHANGSHIURL = "https://ismartbak.mini189.cn/api/"; //智能平台提供的正式key
public final static String PRODUCTCATEGORY = "单宽带"; //只能平台提供的key
// public final static String TOMCATURL = "http://183.57.78.132:8080"; //Linux外网服务器地址
// public final static String INTRANETURL = "http://10.3.1.21:8080"; //Linux内网服务器地址
public final static String TOMCATURL = "http://yrym.winsun-aly.com"; //省windows外网服务器地址
public final static String INTRANETURL = "http://172.51.229.10:8081"; //省windows内网服务器地址
// public final static String TOMCATURL = "http://ue189.com:8529"; //服务器地址
// public final static String INTRANETURL = "http://ue189.com:8529"; //服务器地址
// public final static String TOMCATURL = "http://127.0.0.1:8080"; //服务器地址
// public final static String INTRANETURL = "http://127.0.0.1:8080"; //服务器地址
public final static String PRODUCTSKU481 = "481"; //产品sku:校园宽带300元/年
public final static String PRODUCTSKU479 = "479"; //产品sku:校园宽带30元/月
public final static String PRODUCTSKU479Str = "30元"; //产品sku:校园宽带30元/月
public final static String PRODUCTSKU481Str = "300元"; //产品sku:校园宽带30元/月
public final static String Payment0 = "0"; //支付方式：为翼支付网厅
public final static String Payment1 = "1"; //支付方式：为支付宝
public final static String Payment3 = "3"; //支付方式：为微信支付
public static final String VALIDATECODE_SESSION_KEY = "validatecode"; // 验证码 session key
/*宽带图片*/
public final static String KUANDAIIMAGE = "kuandai";//封面图
public final static String IMGBDURL = "/static/images/temp/";//图片存放位置
public final static String KDIMGBDURL = "/static/images/kuandai/";//图片存放位置
public final static String ORDERSTATUS1 = "1"; // 待提交
public final static String ORDERSTATUS2 = "2"; // 待受理
public final static String ORDERSTATUS3 = "3"; // 受理成功【待收费】
public final static String ORDERSTATUS4 = "4"; // 归档
public final static String ORDERSTATUS5 = "5"; // 作废
public final static String ORDERSTATUS9 = "9"; // 已收费【待竣工】
public final static String ORDERSTATUS10 = "10"; // 受理异常
public final static String ORDERSTATUS100= "100"; // 未支付
public final static String ROLE1 = "1"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
public final static String ROLE2 = "2"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
public final static String ROLE3 = "3"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
public final static String ROLE4 = "4"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
}
common/src/main/java/com/winsun/bean/NetworkInfo.java 0 → 100644
package com.winsun.bean;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;
import java.io.Serializable;
/**
* 网点信息类
*/
@Data
@TableName("hhr_network_info")
public class NetworkInfo implements Serializable {
private static final long serialVersionUID = 5797224009939724683L;
/**
* 主键id
*/
@TableId(value = "id", type = IdType.AUTO)
private String id;
/**
* 局向，区名
*/
private String areaName;
/**
* 学校名
*/
private String schoolName;
/**
* 网点编码
*/
private String networkCode;
/**
* 网点名称
*/
private String networkName;
}
common/src/main/java/com/winsun/bean/Order.java
package com.winsun.bean;
import java.io.Serializable;
import java.util.Date;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableName;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* 订单
*
......@@ -15,7 +14,8 @@ import lombok.Data;
@Data
@TableName("hhr_order")
public class Order implements Serializable{
private static final long serialVersionUID = 1052451021982452911L;
/**
* 主键
*/
......@@ -197,7 +197,7 @@ public class Order implements Serializable{
/**
* 提交佣金系统次数
*/
private int yjCount;
private String yjCount;
/**
* 提交佣金系统结果
......@@ -207,12 +207,12 @@ public class Order implements Serializable{
/**
* 新用户提交方式0督导1本人
*/
private int tjType;
private String tjType;
/**
* 小白卡1单移 2融合
*/
private int xbType;
private String xbType;
/**
* 宽带账号
......
common/src/main/java/com/winsun/bean/OrderHistory.java 0 → 100644
package com.winsun.bean;
import com.baomidou.mybatisplus.annotations.TableName;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
/**
* (OrderHistory)实体类
*
* @author PXL
* @since 2020-02-18 16:56:54
*/
@Data
@TableName("hhr_order_history")
public class OrderHistory implements Serializable {
private static final long serialVersionUID = -40129957672095334L;
/**
* 订单id
*/
private String orderId;
/**
* 订单状态
*/
private String status;
/**
*
*/
private Date createDate;
/**
* 操作人
*/
private String operator;
}
common/src/main/java/com/winsun/bean/OrderView.java
package com.winsun.bean;
import com.baomidou.mybatisplus.annotations.TableField;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;
import java.util.Date;
import java.io.Serializable;
......@@ -13,6 +15,7 @@ import java.io.Serializable;
* @author makejava
* @since 2020-02-18 16:56:54
*/
@Data
@TableName("order_view")
public class OrderView implements Serializable {
private static final long serialVersionUID = -61996751798804758L;
......@@ -24,311 +27,127 @@ public class OrderView implements Serializable {
/**
* 订单号码
*/
private String orderseq;
@TableField(value = "orderSeq")
private String orderSeq;
/**
* 产品名称
*/
private String productname;
@TableField(value = "productName")
private String productName;
/**
* 套餐
*/
@TableField(value = "order_set_meal")
private String orderSetMeal;
/**
* 学校
*/
@TableField(value = "order_university_name")
private String orderUniversityName;
/**
* 姓名
*/
private String ordername;
@TableField(value = "orderName")
private String orderName;
/**
* 提交时间
*/
private Date orderdate;
@TableField(value = "orderDate")
private Date orderDate;
/**
* 订单状态
*/
@TableField(value = "status")
private String status;
/**
* 区域
*/
@TableField(value = "order_region")
private String orderRegion;
/**
* 支付平台：翼支付网厅|支付宝|微信
*/
private String ipay;
@TableField(value = "ipay")
private String iPay;
/**
* 支付方式：电脑支付|手机WAY支付|微信扫码支付|公众号支付|支付宝扫码
*/
private String paytype;
@TableField(value = "payType")
private String payType;
/**
* 产品价格
*/
private String weborderamount;
@TableField(value = "webOrderAmount")
private String webOrderAmount;
/**
* 支付时间
*/
@TableField(value = "order_payment_time")
private Date orderPaymentTime;
/**
* 穗易付订单号
*/
private String orderreqtranseq;
@TableField(value = "orderReqtranSeq")
private String orderReqtranSeq;
/**
* 接入商
*/
private String customerid;
@TableField(value = "customeRid")
private String customerId;
/**
* 联系电话
*/
private String orderphone;
@TableField(value = "orderPhone")
private String orderPhone;
/**
* 身份证号码
*/
private String ordernumber;
@TableField(value = "orderNumber")
private String orderNumber;
/**
* 用户类别
*/
@TableField(value = "order_customer_type")
private String orderCustomerType;
/**
* 学生证号
*/
@TableField(value = "order_customer_student_id")
private String orderCustomerStudentId;
/**
* 备注
*/
@TableField(value = "order_customer_remarks")
private String orderCustomerRemarks;
/**
* 多媒体账号
*/
@TableField(value = "order_customer_account")
private String orderCustomerAccount;
/**
* 多媒体密码
*/
@TableField(value = "order_customer_pwd")
private String orderCustomerPwd;
/**
* 支付平台流水号
*/
@TableField(value = "uptranseq")
private String uptranseq;
/**
* 用户显示的速率
*/
@TableField(value = "expenses")
private String expenses;
/**
* 预留字段2
*/
@TableField(value = "order_rf2")
private String orderRf2;
/**
* 智能平台订单号
*/
private String orderseqthd;
public Integer getOrderId() {
return orderId;
}
public void setOrderId(Integer orderId) {
this.orderId = orderId;
}
public String getOrderseq() {
return orderseq;
}
public void setOrderseq(String orderseq) {
this.orderseq = orderseq;
}
public String getProductname() {
return productname;
}
public void setProductname(String productname) {
this.productname = productname;
}
public String getOrderSetMeal() {
return orderSetMeal;
}
public void setOrderSetMeal(String orderSetMeal) {
this.orderSetMeal = orderSetMeal;
}
public String getOrderUniversityName() {
return orderUniversityName;
}
public void setOrderUniversityName(String orderUniversityName) {
this.orderUniversityName = orderUniversityName;
}
public String getOrdername() {
return ordername;
}
public void setOrdername(String ordername) {
this.ordername = ordername;
}
public Date getOrderdate() {
return orderdate;
}
public void setOrderdate(Date orderdate) {
this.orderdate = orderdate;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getOrderRegion() {
return orderRegion;
}
public void setOrderRegion(String orderRegion) {
this.orderRegion = orderRegion;
}
public String getIpay() {
return ipay;
}
public void setIpay(String ipay) {
this.ipay = ipay;
}
public String getPaytype() {
return paytype;
}
public void setPaytype(String paytype) {
this.paytype = paytype;
}
public String getWeborderamount() {
return weborderamount;
}
public void setWeborderamount(String weborderamount) {
this.weborderamount = weborderamount;
}
public Date getOrderPaymentTime() {
return orderPaymentTime;
}
public void setOrderPaymentTime(Date orderPaymentTime) {
this.orderPaymentTime = orderPaymentTime;
}
public String getOrderreqtranseq() {
return orderreqtranseq;
}
public void setOrderreqtranseq(String orderreqtranseq) {
this.orderreqtranseq = orderreqtranseq;
}
public String getCustomerid() {
return customerid;
}
public void setCustomerid(String customerid) {
this.customerid = customerid;
}
public String getOrderphone() {
return orderphone;
}
public void setOrderphone(String orderphone) {
this.orderphone = orderphone;
}
public String getOrdernumber() {
return ordernumber;
}
public void setOrdernumber(String ordernumber) {
this.ordernumber = ordernumber;
}
public String getOrderCustomerType() {
return orderCustomerType;
}
public void setOrderCustomerType(String orderCustomerType) {
this.orderCustomerType = orderCustomerType;
}
public String getOrderCustomerStudentId() {
return orderCustomerStudentId;
}
public void setOrderCustomerStudentId(String orderCustomerStudentId) {
this.orderCustomerStudentId = orderCustomerStudentId;
}
public String getOrderCustomerRemarks() {
return orderCustomerRemarks;
}
public void setOrderCustomerRemarks(String orderCustomerRemarks) {
this.orderCustomerRemarks = orderCustomerRemarks;
}
public String getOrderCustomerAccount() {
return orderCustomerAccount;
}
public void setOrderCustomerAccount(String orderCustomerAccount) {
this.orderCustomerAccount = orderCustomerAccount;
}
public String getOrderCustomerPwd() {
return orderCustomerPwd;
}
public void setOrderCustomerPwd(String orderCustomerPwd) {
this.orderCustomerPwd = orderCustomerPwd;
}
public String getUptranseq() {
return uptranseq;
}
public void setUptranseq(String uptranseq) {
this.uptranseq = uptranseq;
}
public String getExpenses() {
return expenses;
}
public void setExpenses(String expenses) {
this.expenses = expenses;
}
public String getOrderRf2() {
return orderRf2;
}
public void setOrderRf2(String orderRf2) {
this.orderRf2 = orderRf2;
}
public String getOrderseqthd() {
return orderseqthd;
}
public void setOrderseqthd(String orderseqthd) {
this.orderseqthd = orderseqthd;
}
@TableField(value = "orderSeqTHD")
private String orderseqThd;
}
\ No newline at end of file
common/src/main/java/com/winsun/bean/Package.java
......@@ -14,6 +14,7 @@ import java.io.Serializable;
@TableName("hhr_package")
public class Package implements Serializable {
private static final long serialVersionUID = -3214488372758625311L;
/**
* 主键
*/
......
common/src/main/java/com/winsun/bean/Partner.java
......@@ -15,6 +15,7 @@ import java.io.Serializable;
@TableName("hhr_user_view")
public class Partner implements Serializable {
private static final long serialVersionUID = -2297946603543248406L;
/**
* 主键
*/
......
common/src/main/java/com/winsun/bean/Product.java
......@@ -110,4 +110,6 @@ public class Product implements Serializable {
private String productIntroductionPic4;
private String productIntroductionPic5;
private int universityId;
}
common/src/main/java/com/winsun/bean/School.java
......@@ -15,6 +15,7 @@ import java.io.Serializable;
@TableName("hhr_school")
public class School implements Serializable {
private static final long serialVersionUID = 6881513580528426846L;
/**
* 主键
*/
......@@ -102,8 +103,12 @@ public class School implements Serializable {
* 是否显示融合
*/
private String isShowrh;
/**
* 网点编码
*/
private String networkCode;
/**
* 网点名称
*/
private String networkName;
}
common/src/main/java/com/winsun/bean/Student.java 0 → 100644
package com.winsun.bean;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;
import java.io.Serializable;
/**
* 学生信息
*/
@Data
@TableName("hhr_student")
public class Student implements Serializable {
private static final long serialVersionUID = 3949626453448235989L;
/**
*主键
*/
@TableId(value = "id", type = IdType.AUTO)
private String id;
/**
*学生姓名
*/
private String stuName;
/**
*学生身份证号
*/
private String idCard;
/**
*专业
*/
private String worker;
/**
*班级
*/
private String aClass;
}
common/src/main/java/com/winsun/bean/SysUser.java
......@@ -6,16 +6,17 @@ import com.baomidou.mybatisplus.annotations.TableName;
import com.baomidou.mybatisplus.enums.IdType;
import lombok.Data;
import java.io.Serializable;
import java.util.Date;
@TableName("sys_user")
@Data
public class SysUser {
public class SysUser implements Serializable {
/**
* 主键
*/
@TableId(type = IdType.AUTO)
@TableId(value = "id",type = IdType.AUTO)
private String id;
/**
......
common/src/main/java/com/winsun/bean/UserSchool.java 0 → 100644
package com.winsun.bean;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import lombok.Data;
import java.io.Serializable;
/**
* 学校信息
*/
@Data
@TableName("hhr_user_school")
public class UserSchool implements Serializable {
private static final long serialVersionUID = 2140472662677454235L;
/**
* 主键
*/
@TableId(value = "user_id")
private String userId;
/**
*
*/
private String schoolId;
}
common/src/main/java/com/winsun/constant/Constant.java 0 → 100644
package com.winsun.constant;
/**
* @author ljh
* @Description:常量类
* @Title: Constant
* @date 2018年5月16日下午6:55:54
* @version 1.0
*/
public class Constant {
/* 默认一页显示10条数据 */
public final static Integer PAGENUM = 2;
/* 默认第一页 */
public final static Integer FROMPAGE = 0;
/*用户状态*/
public final static String USERQIDONG = "1";//启用
public final static String USERJINYONG = "0";//禁用
/*支付参数*/
public final static String CLIENTNUMBER = "xyzxyql"; //商户标识，由穗易付平台统一分配
public final static String KEY = "E805F0305C455BA7C5BAE3796C6500BD"; //商户标识，由穗易付平台统一分配
public final static String USERNAME = "apitest"; //智能平台提供测试的账号
public final static String USERNAMEKEY = "46b97294d4dac3f62ee42f3ab2804f68"; //智能平台提供的测试key
public final static String ZHENGSHIAUCCON = "ruany"; //智能平台提供的正式账号
public final static String ZHANGSHIKEY = "3df143292455bfea88bc613c53004d36"; //智能平台提供的正式key
// public final static String ZHENGSHIAUCCON = "xiaoykd"; //智能平台提供的正式账号
// public final static String ZHANGSHIKEY = "d345040accff0421d03f760a03e5cbd9"; //智能平台提供的正式key
public final static String ZHANGSHIURL = "https://ismartbak.mini189.cn/api/"; //智能平台提供的正式key
public final static String PRODUCTCATEGORY = "单宽带"; //只能平台提供的key
// public final static String TOMCATURL = "http://183.57.78.132:8080"; //Linux外网服务器地址
// public final static String INTRANETURL = "http://10.3.1.21:8080"; //Linux内网服务器地址
public final static String TOMCATURL = "http://yrym.winsun-aly.com"; //省windows外网服务器地址
public final static String INTRANETURL = "http://172.51.229.10:8081"; //省windows内网服务器地址
// public final static String TOMCATURL = "http://ue189.com:8529"; //服务器地址
// public final static String INTRANETURL = "http://ue189.com:8529"; //服务器地址
// public final static String TOMCATURL = "http://127.0.0.1:8080"; //服务器地址
// public final static String INTRANETURL = "http://127.0.0.1:8080"; //服务器地址
public final static String PRODUCTSKU481 = "481"; //产品sku:校园宽带300元/年
public final static String PRODUCTSKU479 = "479"; //产品sku:校园宽带30元/月
public final static String PRODUCTSKU479Str = "30"; //产品sku:校园宽带30元/月
public final static String PRODUCTSKU481Str = "300"; //产品sku:校园宽带30元/月
public final static String Payment0 = "0"; //支付方式：为翼支付网厅
public final static String Payment1 = "1"; //支付方式：为支付宝
public final static String Payment3 = "3"; //支付方式：为微信支付
public static final String VALIDATECODE_SESSION_KEY = "validatecode"; // 验证码 session key
/*宽带图片*/
public final static String KUANDAIIMAGE = "kuandai";//封面图
public final static String IMGBDURL = "/static/images/temp/";//图片存放位置
public final static String KDIMGBDURL = "/static/images/kuandai/";//图片存放位置
public final static String ORDERSTATUS1 = "1"; // 待提交
public final static String ORDERSTATUS2 = "2"; // 待受理
public final static String ORDERSTATUS3 = "3"; // 受理成功【待收费】
public final static String ORDERSTATUS4 = "4"; // 归档
public final static String ORDERSTATUS5 = "5"; // 作废
public final static String ORDERSTATUS9 = "9"; // 已收费【待竣工】
public final static String ORDERSTATUS10 = "10"; // 受理异常
public final static String ORDERSTATUS100= "100"; // 未支付
public final static String ROLE1 = "1"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
public final static String ROLE2 = "2"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
public final static String ROLE3 = "3"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
public final static String ROLE4 = "4"; // 用户权限：1管理员 2测试人员 3工作人员 4学校人员
}
common/src/main/java/com/winsun/mapper/NetworkInfoMapper.java 0 → 100644
package com.winsun.mapper;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.winsun.bean.NetworkInfo;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Component;
@Mapper
@Component
public interface NetworkInfoMapper extends BaseMapper<NetworkInfo> {
}
common/src/main/java/com/winsun/mapper/OrderHistoryMapper.java 0 → 100644
package com.winsun.mapper;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.winsun.bean.OrderHistory;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Component;
@Mapper
@Component
public interface OrderHistoryMapper extends BaseMapper<OrderHistory> {
}
common/src/main/java/com/winsun/mapper/SchoolMapper.java
......@@ -2,7 +2,6 @@ package com.winsun.mapper;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.winsun.bean.School;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
......@@ -20,4 +19,5 @@ public interface SchoolMapper extends BaseMapper<School> {
@Select("select school_id schoolId from `hhr_user_school` where user_id = #{partner}")
String selectSchoolIdByUserId(String partner);
}
common/src/main/java/com/winsun/mapper/StudentMapper.java 0 → 100644
package com.winsun.mapper;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.winsun.bean.Student;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Component;
import java.util.Map;
@Mapper
@Component
public interface StudentMapper extends BaseMapper<Student> {
@Select("SELECT * FROM hhr_student WHERE stu_name = #{name} AND id_card = #{idCard}")
Map<String,Object> selectStudentByNameAndIdCard(@Param("name") String name, @Param("idCard") String idCard);
@Select("SELECT * FROM hhr_student WHERE id = #{id}")
Map<String,Object> getStuById(@Param("id") String id);
}
common/src/main/java/com/winsun/mapper/UserSchoolMapper.java 0 → 100644
package com.winsun.mapper;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import com.winsun.bean.UserSchool;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Component;
@Mapper
@Component
public interface UserSchoolMapper extends BaseMapper<UserSchool> {
}
common/src/main/java/com/winsun/smsUtils/GetAccessToken.java
package com.winsun.smsUtils;
import lombok.extern.slf4j.Slf4j;
import java.util.HashMap;
import java.util.Map;
/**
* 令牌获取
*/
@Slf4j
public class GetAccessToken {
public static void main(String[] args) {
......@@ -26,7 +29,7 @@ public class GetAccessToken {
try {
String test = HttpUtil.httpPostMethodNoReTryWithStr(url,requestData);
System.out.println(test);
log.info(test);
} catch (Exception e) {
e.printStackTrace();
}
......@@ -42,14 +45,14 @@ public class GetAccessToken {
String clientType = "10001";
Map<String,String> requestData = new HashMap<>();
requestData.put("timeStamp",String.valueOf(System.currentTimeMillis()));
System.out.println(requestData);
log.info(requestData.toString());
RequestParasUtil.setParas(requestData,appKey,appSecret,version,format,clientType);
try {
System.out.println(requestData);
log.info(requestData.toString());
String accesstoken = HttpUtil.httpPostMethodNoReTryWithStr(url,requestData);
System.out.println(accesstoken);
log.info(accesstoken);
return accesstoken;
} catch (Exception e) {
e.printStackTrace();
......
common/src/main/java/com/winsun/smsUtils/HttpUtil.java
package com.winsun.smsUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpHost;
......@@ -19,6 +20,7 @@ import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Slf4j
public class HttpUtil {
public static int httpPostMethodNoReTry( String url, Map<String, String> pairs ) throws Exception {
......@@ -82,7 +84,7 @@ public class HttpUtil {
.setProxy(proxy).build();
request.setConfig(requestConfig);
// 发�?�请�?
System.out.println(request);
log.info(request.getMethod());
CloseableHttpResponse response = httpclient.execute(request);
HttpEntity entity = response.getEntity();
ret = EntityUtils.toString(entity);
......
common/src/main/java/com/winsun/smsUtils/RequestParasUtil.java
package com.winsun.smsUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
@Slf4j
public class RequestParasUtil {
public RequestParasUtil() {
......@@ -50,7 +51,7 @@ public class RequestParasUtil {
requestData.put("clientType", clientType);
requestData.put("format", format);
requestData.put("paras", cipherParas);
// System.out.println("appSecret:"+appSecret);
// log.info("appSecret:"+appSecret);
String plainSig = appKey + clientType + format + version + cipherParas;
requestData.put("sign", generateHmacSignature(plainSig, appSecret));
} else {
......
common/src/main/java/com/winsun/smsUtils/SendSmsAndMail.java
package com.winsun.smsUtils;
import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONObject;
import java.util.*;
@Slf4j
public class SendSmsAndMail {
public static void main(String[] args) {
......@@ -12,17 +14,17 @@ public class SendSmsAndMail {
"13697427771/t1836@sise.cn/660040Abca"
);
obj.addAll(list);
System.out.println(obj.size());
for (String s : obj) {
String[] split = s.split("/");
System.out.println(split[0]+"--"+split[1]+"---"+split[2]);
// System.out.println(sendSms(s,"http://yrym.winsun-aly.com/gdtel-xyzx-hhr/customer/plan.do?orderId=d70f3423a6f","2"));
System.out.println("返回："+sendSms("11111111111","111111","7"));
log.info(split[0]+"--"+split[1]+"---"+split[2]);
// log.info(sendSms(s,"http://yrym.winsun-aly.com/gdtel-xyzx-hhr/customer/plan.do?orderId=d70f3423a6f","2"));
log.info("返回："+sendSms("11111111111","111111","7"));
}
System.out.println("发送完成");
log.info("发送完成");
// String res = BaiduDwz.createShortUrl("http://yrym.winsun-aly.com/gdtel-xyzx-hhr/customer/plan.do?orderId=d70f3423a6f");
// 生成url
// System.out.println(res);
// log.info(res);
}
......
common/src/main/java/com/winsun/smsUtils/XXTea.java
package com.winsun.smsUtils;
import lombok.extern.slf4j.Slf4j;
/**
* XXTea加解密实�?
*/
@Slf4j
public class XXTea {
/**
......@@ -211,12 +215,12 @@ public class XXTea {
long t1 = System.currentTimeMillis();
String cipherText =
XXTea.encrypt(plainText,"UTF-8",ByteFormat.toHex(key));
System.out.println(cipherText);
log.info(cipherText);
String pText = XXTea.decrypt(cipherText,"UTF-8",ByteFormat.toHex(key));
System.out.println(pText);
log.info(pText);
long t2 = System.currentTimeMillis();
System.out.println(t2-t1);
log.info((t2-t1) + "");
}catch(Exception ex){
ex.printStackTrace();
}
......
common/src/main/java/com/winsun/utils/BeanUtil.java 0 → 100644
package com.winsun.utils;
import java.util.List;
import java.util.Map;
/**
* 判断bean，数组，集合是否为空
*
* @author liujianhao
*
*/
public class BeanUtil {
public static boolean isBlank(Object obj) {
if (obj == null) {
return true;
}
return false;
}
public static boolean isBlank(List<?> list) {
if (list == null || list.size() <= 0) {
return true;
}
return false;
}
public static boolean isBlank(Map<?, ?> map) {
if (map == null || map.size() <= 0) {
return true;
}
return false;
}
public static boolean isBlank(Object[] obj) {
if (obj == null || obj.length <= 0) {
return true;
}
return false;
}
public static boolean isNotBlank(Object obj) {
return !isBlank(obj);
}
public static boolean isNotBlank(List<?> list) {
return !isBlank(list);
}
public static boolean isNotBlank(Map<?, ?> map) {
return !isBlank(map);
}
public static boolean isNotBlank(Object[] obj) {
return !isBlank(obj);
}
}
common/src/main/java/com/winsun/utils/ProduceIdUtil.java 0 → 100644
package com.winsun.utils;
/**
* @Author xuede
* @Date 2020/2/5 22:58
* @Version 1.0
*/
public class ProduceIdUtil {
private long workerId;
private long datacenterId;
private long sequence = 0L;
private long twepoch = 1580914838112L; // Thu, 04 Nov 2020-02-05 23:00:00 GMT 标记时间 用来计算偏移量，距离当前时间不同，得到的数据的位数也不同
private long workerIdBits = 5L; // 物理节点ID长度
private long datacenterIdBits = 5L; // 数据中心ID长度
private long maxWorkerId = -1L ^ (-1L << workerIdBits); // 最大支持机器节点数0~31，一共32个
private long maxDatacenterId = -1L ^ (-1L << datacenterIdBits); // 最大支持数据中心节点数0~31，一共32个
private long sequenceBits = 12L; // 序列号12位， 4095，同毫秒内生成不同id的最大个数
private long workerIdShift = sequenceBits; // 机器节点左移12位
private long datacenterIdShift = sequenceBits + workerIdBits; // 数据中心节点左移17位
private long timestampLeftShift = sequenceBits + workerIdBits + datacenterIdBits; // 时间毫秒数左移22位
private long sequenceMask = -1L ^ (-1L << sequenceBits); // 用于和当前时间戳做比较，以获取最新时间
private long lastTimestamp = -1L;
//成员类，SnowFlakeUtil的实例对象的保存域
private static class IdGenHolder {
private static final ProduceIdUtil instance = new ProduceIdUtil();
}
//外部调用获取SnowFlakeUtil的实例对象，确保不可变
public static ProduceIdUtil get(){
return IdGenHolder.instance;
}
//初始化构造，无参构造有参函数，默认节点都是0
public ProduceIdUtil() {
this(0L, 0L);
}
//设置机器节点和数据中心节点数，都是 0-31
public ProduceIdUtil(long workerId, long datacenterId) {
if (workerId > maxWorkerId || workerId < 0) {
throw new IllegalArgumentException(String.format("worker Id can't be greater than %d or less than 0", maxWorkerId));
}
if (datacenterId > maxDatacenterId || datacenterId < 0) {
throw new IllegalArgumentException(String.format("datacenter Id can't be greater than %d or less than 0", maxDatacenterId));
}
this.workerId = workerId;
this.datacenterId = datacenterId;
}
//线程安全的id生成方法
@SuppressWarnings("all")
public synchronized long nextId() {
//获取当前毫秒数
long timestamp = timeGen();
//如果服务器时间有问题(时钟后退) 报错。
if (timestamp < lastTimestamp) {
throw new RuntimeException(String.format(
"Clock moved backwards. Refusing to generate id for %d milliseconds", lastTimestamp - timestamp));
}
//如果上次生成时间和当前时间相同,在同一毫秒内
if (lastTimestamp == timestamp) {
//sequence自增，因为sequence只有12bit，所以和sequenceMask相与一下，去掉高位
sequence = (sequence + 1) & sequenceMask;
//判断是否溢出,也就是每毫秒内超过4095，当为4096时，与sequenceMask相与，sequence就等于0
if (sequence == 0) {
//自旋等待到下一毫秒
timestamp = tilNextMillis(lastTimestamp);
}
} else {
//如果和上次生成时间不同,重置sequence，就是下一毫秒开始，sequence计数重新从0开始累加，每个毫秒时间内，都是从0开始计数，最大4095
sequence = 0L;
}
lastTimestamp = timestamp;
// 最后按照规则拼出ID 64位
// 000000000000000000000000000000000000000000 00000 00000 000000000000
//1位固定整数 time datacenterId workerId sequence
return ((timestamp - twepoch) << timestampLeftShift) | (datacenterId << datacenterIdShift)
| (workerId << workerIdShift) | sequence;
}
//比较当前时间和过去时间，防止时钟回退（机器问题），保证给的都是最新时间/最大时间
protected long tilNextMillis(long lastTimestamp) {
long timestamp = timeGen();
while (timestamp <= lastTimestamp) {
timestamp = timeGen();
}
return timestamp;
}
//获取当前的时间戳（毫秒）
protected long timeGen() {
return System.currentTimeMillis();
}
/**
* 获取全局唯一编码
*/
public static Long getId(){
Long id = ProduceIdUtil.get().nextId();
return id;
}
}
common/src/main/java/com/winsun/utils/XbkUtil.java
......@@ -17,6 +17,7 @@ import java.util.Map;
@Slf4j
public class XbkUtil {
public static JSONObject xbkCreate(Map<String, Object> map, String type){
Map<String, Object> mapParm = new HashMap<>();
Date now = new Date();
......
core-service/src/main/java/com/winsun/item/modular/system/controller/GetPhoneCodeController.java
......@@ -24,8 +24,6 @@ import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* 日志管理的控制器
......
deploy/prod/pushToDocker.sh 0 → 100755
#!/bin/bash
## 推送到公司的docker私库，暂时是试用的
cp ../../eureka/target/*.jar docker-gdtel-gztel-hhr/eureka/
cp ../../gateway/target/*.jar docker-gdtel-gztel-hhr/gateway/
cp ../../core-service/target/*.jar docker-gdtel-gztel-hhr/core/
cp ../../apply-net/target/*.jar docker-gdtel-gztel-hhr/applynet/
cp ../../service-manager/target/*.jar docker-gdtel-gztel-hhr/manager/
cp ../../new-user/target/*.jar docker-gdtel-gztel-hhr/newuser/
cp ../../old-user/target/*.jar docker-gdtel-gztel-hhr/olduser/
cp ../../task/target/*.jar docker-gdtel-gztel-hhr/task/
cd docker-gdtel-gztel-hhr/
cd eureka
docker build -t 172.18.101.172:5000/eureka . && docker push 172.18.101.172:5000/eureka
cd ../gateway
docker build -t 172.18.101.172:5000/gateway . && docker push 172.18.101.172:5000/gateway
enclosure/export/20200327/订单清单20200327.xls 0 → 100644
++ "b/enclosure/export/20200327/\350\256\242\345\215\225\346\270\205\345\215\22520200327.xls"
gateway/src/main/resources/application.yml
......@@ -27,7 +27,7 @@ spring:
max-file-size: 100MB
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://172.18.101.171:3306/ws_project?useSSL=false
url: jdbc:mysql://172.18.101.171:3306/school_center?useSSL=false
username: root
password: AMrGBg6ZSsRrDLs6
zuul:
......
new-user/src/main/java/com/winsun/controller/PackageNewClothes.java
......@@ -14,6 +14,7 @@ import com.winsun.constant.UserType;
import com.winsun.mapper.*;
import com.winsun.utils.IDCardUtil;
import com.winsun.utils.PicturesUtil;
import com.winsun.utils.ProduceIdUtil;
import com.winsun.utils.XbkUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
......@@ -195,21 +196,22 @@ public class PackageNewClothes {
Date date = new Date();
order.setCreateTime(date);
order.setUserType(UserType.NEWCUSTOMER.getId());
SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
String format = yyyyMMdd.format(date);
String s = String.valueOf((int) ((Math.random() * 9 + 1) * 1000));
order.setOrderNumber("YRYM" + format + s);
order.setOrderNumber("YRYM" + ProduceIdUtil.getId());
order.setHehuorenArea(sysUser.getSubstName());
order.setHehuorenName(sysUser.getName());
String schoolId = appMapper.selectSchoolId(partner);
String schoolName = appMapper.selectSchoolById(schoolId);
order.setHehuorenSchool(schoolName);
School school=schoolMapper.selectById(schoolId);
order.setHehuorenSchool(school.getSchoolName());
order.setHehuorenPhone(sysUser.getPhone());
List<String> userId = appMapper.selectsupervisorBySchool(schoolId);
SysUser user = userMapper.selectById(userId.get(0));
order.setSupervisorName(user.getName());
order.setLzgh(school.getLzgh());
Integer insert = orderMapper.insert(order);
// MessageUtil.sent(contactNumber,"4","");
if (insert == 1) {
appMapper.inserOrderHis(id, "资料已提交", date, sysUser.getName());
appMapper.inserOrderHis(id, "资料已提交", date, customerName);
return ResponseData.success(id);
}
return ResponseData.error("开卡失败！");
......@@ -298,20 +300,21 @@ public class PackageNewClothes {
Date date = new Date();
order.setCreateTime(date);
order.setUserType(UserType.NEWCUSTOMER.getId());
SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
String format = yyyyMMdd.format(date);
String s = String.valueOf((int) ((Math.random() * 9 + 1) * 1000));
order.setOrderNumber("YRYM" + format + s);
order.setOrderNumber("YRYM" + ProduceIdUtil.getId());
order.setHehuorenArea(sysUser.getSubstName());
order.setHehuorenName(sysUser.getName());
String schoolId = appMapper.selectSchoolId(partner);
String schoolName = appMapper.selectSchoolById(schoolId);
order.setHehuorenSchool(schoolName);
School school=schoolMapper.selectById(schoolId);
order.setHehuorenSchool(school.getSchoolName());
order.setHehuorenPhone(sysUser.getPhone());
List<String> userId = appMapper.selectsupervisorBySchool(schoolId);
SysUser user = userMapper.selectById(userId.get(0));
order.setSupervisorName(user.getName());
order.setLzgh(school.getLzgh());
Integer insert = orderMapper.insert(order);
// MessageUtil.sent(contactNumber,"4","");
if (insert == 1) {
appMapper.inserOrderHis(id, "资料已提交", date, sysUser.getName());
appMapper.inserOrderHis(id, "资料已提交", date, customerName);
return ResponseData.success(id);
}
return ResponseData.error("开卡失败！");
......@@ -401,7 +404,7 @@ public class PackageNewClothes {
order.setOrderStatus("待识别");
order.setUserSchool(userSchool);
order.setHehuorenId(partner);
order.setXbType(1);
order.setXbType("1");
if(StringUtils.isNotBlank(site)){
order.setSite(site);
}
......@@ -418,10 +421,7 @@ public class PackageNewClothes {
Date date = new Date();
order.setCreateTime(date);
order.setUserType(UserType.NEWCUSTOMER.getId());
SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
String format = yyyyMMdd.format(date);
String s = String.valueOf((int) ((Math.random() * 9 + 1) * 1000));
order.setOrderNumber("YRYM" + format + s);
order.setOrderNumber("YRYM" + ProduceIdUtil.getId());
order.setHehuorenArea(sysUser.getSubstName());
order.setHehuorenName(sysUser.getName());
order.setHehuorenSchool(school.getSchoolName());
......@@ -434,7 +434,7 @@ public class PackageNewClothes {
// MessageUtil.sent(contactNumber,"4","");
if (insert == 1) {
appMapper.inserOrderHis(id, "资料提交成功,等待上传证件", date, sysUser.getName());
appMapper.inserOrderHis(id, "资料提交成功,等待上传证件", date, customerName);
return ResponseData.success(map.get("orderCode").toString());
}
return ResponseData.error("开卡失败！");
......
new-user/src/main/java/com/winsun/controller/StartSelectController.java
package com.winsun.controller;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.winsun.auth.core.common.model.ResponseData;
import com.winsun.mapper.SchoolMapper;
import com.winsun.mapper.SchoolPackageMapper;
import com.winsun.bean.*;
import com.winsun.mapper.*;
import com.winsun.smsUtils.SendSmsAndMail;
import com.winsun.utils.MD5Utils;
import com.winsun.utils.ProduceIdUtil;
import lombok.extern.slf4j.Slf4j;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* @Author xuede
......@@ -23,7 +43,22 @@ import java.util.Map;
public class StartSelectController {
@Autowired
private SchoolMapper schoolMapper;
private UserSchoolMapper userSchoolMapper;
@Autowired
private SysUserMapper sysUserMapper;
@Autowired
private SchoolMapper schoolMapper;
@Autowired
private StudentMapper studentMapper;
@Autowired
private ProductMapper productMapper;
@Autowired
private OrderMapper orderMapper;
@Autowired
private OrderHistoryMapper historyMapper;
@Autowired
private UniversityInfoMapper universityInfoMapper;
@RequestMapping("/findStartData")
public ResponseData<Map<String, Object>> findStartData(@RequestParam("id") String id){
......@@ -37,4 +72,594 @@ public class StartSelectController {
Map<String, Object> map = mapList.get(0);
return ResponseData.success(map);
}
/**
*通过学生ID，name和身份证查询学生信息
* @param stuId 学生ID
* @param name 用户名
* @param idCard 身份证号
* @return
*/
@ResponseBody
@RequestMapping(value = "checkStudent", method = RequestMethod.POST)
public ResponseData<Map<String, Object>> checkStudent(String stuId,String name,String idCard){
Wrapper<Student> studentWrapper = new EntityWrapper<>();
studentWrapper.setSqlSelect("id,stu_name AS stuName,id_card AS idCard,worker,aClass");
if (StringUtils.isNotBlank(stuId)){
studentWrapper.addFilter("id = '"+stuId+"'");
}
if (StringUtils.isNotBlank(name)){
studentWrapper.addFilter("stu_name = '"+name+"'");
}
if (StringUtils.isNotBlank(idCard)){
studentWrapper.addFilter("id_card = '"+idCard+"'");
}
List<Map<String, Object>> studentMap = studentMapper.selectMaps(studentWrapper);
if (studentMap == null || studentMap.size() == 0) {
return ResponseData.error("该学生信息不存在！");
}
return ResponseData.success(studentMap.get(0),"验证通过");
}
@ResponseBody
@RequestMapping(value = "bysSendCodes", method = RequestMethod.POST)
public ResponseData<Map<String, Object>> checkStudent(String phone) {
Map<String, Object> codeMap = new HashMap<>();
// 生成6位随机数
int random = (int)((Math.random()*9+1)*100000);
String codes = SendSmsAndMail.sendSms(phone,random+"","7");
codeMap.put("codes",random+"");
return ResponseData.success(codeMap);
}
/**
* 手机端主页面，带参数进入手机端主页
* 对订单进去保存和提交订单到智能平台上
*/
@RequestMapping(value = "toBYSOrderSuccessPage")
@ResponseBody
public Map<String, Object> toBYSOrderSuccessPage(HttpServletRequest request, HttpServletResponse response) throws Exception {
Map<String, Object> map = new HashMap();
map.put("code", "0");
log.info("====0元订单提交操作");
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmss");
String currentTimeStr = simpleDateFormat.format(new Date());
Map<String, String[]> parameterMap = request.getParameterMap();
Map<String,String> maps = new HashMap<>();
String orderSeq = ProduceIdUtil.getId().toString();
maps.put("orderSeq",orderSeq);
String productId = "1329"; // 产品id
String saleId = null; // 销售id
JSONObject saleJsonObject = getSaleId(productId, currentTimeStr); // 获取销售ID
log.info("----------调用智能平台的获取销售品接口返回值：" + saleJsonObject);
log.info("----111--" + (saleJsonObject.toString().indexOf("list") == -1));
if (saleJsonObject.toString().indexOf("list") == -1) {
map.put("code", "1");
map.put("error", "销售品获取失败");
return map;
}
JSONArray saleList = saleJsonObject.getJSONArray("list");
log.info("----saleList---：" + saleList);
String saleId1 = "";
String saleId2 = "";
String saleId3 = "";
String saleId4 = "";
for (int i = 0; i < saleList.size(); i++) {
JSONObject itmeJson = JSONObject.fromObject(saleList.get(i));
// 判断获取的全部产品与订单产品符合的拿取对应的ID
if (itmeJson.getString("propertyName").indexOf("单宽带") != -1) {
if (itmeJson.getString("name").equals("单宽_2015年7月-100M/190元")) {
saleId1 = itmeJson.getString("saleId");
maps.put("saleId1",saleId1);
}
} else if (itmeJson.getString("propertyName").indexOf("提速包") != -1) {
if (itmeJson.getString("name").equals("移动老用户升级融合享套餐折扣_6个月")) {
saleId2 = itmeJson.getString("saleId");
maps.put("saleId2",saleId2);
}
} else if (itmeJson.getString("propertyName").indexOf("套餐优惠") != -1) {
if (itmeJson.getString("name").equals("129-5G畅想单品+40元权益金")) {
saleId3 = itmeJson.getString("saleId");
maps.put("saleId3",saleId3);
}
} else if (itmeJson.getString("propertyName").indexOf("一次性收费") != -1) {
if (itmeJson.getString("name").equals("一次性安装调测费200元")) {
saleId4 = itmeJson.getString("saleId");
maps.put("saleId4",saleId4);
}
}
}
// 3、提交订单到智能平台
JSONObject submitOrderJsonObject = getOrderBYSRHInfo(parameterMap, currentTimeStr, productId,maps);
log.info("----------调用融合接口（提交订单至智能平台）并返回参数信息---status:" + submitOrderJsonObject.get("status") + " msg:" + submitOrderJsonObject.get("msg") + " orderNum:" + submitOrderJsonObject.get("orderNumber"));
String orderNum = (String) submitOrderJsonObject.get("orderNumber");
JSONObject queryOrderJsonObject = null;
if (StringUtils.isNotBlank(orderNum)) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Map<String, String> orderMap = new HashMap<>();
orderMap.put("orderSeq", orderSeq);
orderMap.put("productTitle", "中国电信校园高速宽带");
orderMap.put("order_set_meal", "毕业生融合套餐");
orderMap.put("order_university_name", "毕业生");
orderMap.put("orderName", parameterMap.get("userName")[0]);
orderMap.put("orderDatetime", sdf.format(new Date()));
orderMap.put("Status", "待提交");
orderMap.put("universityRegion", "");
orderMap.put("ipay", "0");
orderMap.put("payType", "1");
orderMap.put("prices", "200");
orderMap.put("orderPhone", parameterMap.get("contactNumber")[0]);
orderMap.put("orderNumber", parameterMap.get("identification")[0]);
orderMap.put("expenses", "毕业生融合套餐");
orderMap.put("upStatus", "2");
orderMap.put("partner", parameterMap.get("partner")[0]);
/* 5、更新数据库 */
saveOrderInfo(orderMap,"");
map.put("orderSeq", orderSeq);
}
return map; // 不成功
}
private JSONObject getOrderBYSRHInfo(Map<String, String[]> parameterMap, String currentTimeStr, String productId, Map<String,String> objectMap) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
//HttpHost proxy = new HttpHost("172.18.101.170", 3128);
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(500000)
.setConnectTimeout(500000).setConnectionRequestTimeout(500000).build();
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "create-order.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
Map<String, String> signMap = new HashMap<String, String>();
qParams.add(new BasicNameValuePair("service", "order.combined.create"));// api标识，必填且唯一
signMap.put("service", "order.combined.create");
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));//时间戳（YYYYMMDDHHMMSS） ，必填
signMap.put("timeStamp", currentTimeStr);
qParams.add(new BasicNameValuePair("productCategory", "融合产品"));// 业务类型，必填且唯一
signMap.put("productCategory", "融合产品");
qParams.add(new BasicNameValuePair("transactType", "新宽旧移"));// 办理类型，必填[新宽新移][新宽旧移][旧宽新移][旧宽旧移]
signMap.put("transactType", "新宽旧移");
qParams.add(new BasicNameValuePair("ctNumber", parameterMap.get("bussnessPhone")[0]));// 电信号码，办理类型，若选择[新宽旧移]或[旧宽旧移]，此项必填
signMap.put("ctNumber", parameterMap.get("bussnessPhone")[0]);
String[] split = parameterMap.get("myAddrs")[0].split("/");
qParams.add(new BasicNameValuePair("addressProvince", split[0]));// 报装地址-省 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("addressProvince", split[0]);
qParams.add(new BasicNameValuePair("addressCity", split[1]));// 报装地址-市 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("addressCity", split[1]);
String addressDistrict = split[2];
String address = parameterMap.get("address")[0];
String landId = "56190613";
qParams.add(new BasicNameValuePair("addressDistrict", addressDistrict));// 报装地址-区 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("addressDistrict", addressDistrict);
qParams.add(new BasicNameValuePair("address", address));// 报装地址-详细地址 办理类型，若选择[新宽新移][新宽旧移]，此项必填
signMap.put("address", address);
qParams.add(new BasicNameValuePair("govEntCustomer", "0"));//是否政企客户下单 0：否 1：是，必填
signMap.put("govEntCustomer", "0");
qParams.add(new BasicNameValuePair("agentName", ""));//若是政企客户下单，代办人姓名，必填
signMap.put("agentName", "");
qParams.add(new BasicNameValuePair("agentCardNum", ""));//若是政企客户下单，代办人身份证号码，必填
signMap.put("agentCardNum", "");
qParams.add(new BasicNameValuePair("customerName", parameterMap.get("userName")[0]));// 客户姓名，必填
signMap.put("customerName", parameterMap.get("userName")[0]);
qParams.add(new BasicNameValuePair("customerPhone", parameterMap.get("bussnessPhone")[0]));// 客户电话|代办人电话，必填
signMap.put("customerPhone", parameterMap.get("bussnessPhone")[0]);
qParams.add(new BasicNameValuePair("customerCardType", "身份证"));// 证件类型，必填且只能为身份证
signMap.put("customerCardType", "身份证");
qParams.add(new BasicNameValuePair("customerCardNum", parameterMap.get("identification")[0]));// 证件号码，必填
signMap.put("customerCardNum", parameterMap.get("identification")[0]);
qParams.add(new BasicNameValuePair("landId", landId));// 揽装工号，必填
signMap.put("landId", landId);
qParams.add(new BasicNameValuePair("comarketingLanId", ""));// 协销工号，选填
signMap.put("comarketingLanId", "");
qParams.add(new BasicNameValuePair("groupComarketingLanId", ""));//集团协销工号，选填
signMap.put("groupComarketingLanId", "");
qParams.add(new BasicNameValuePair("orderOutNum",objectMap.get("orderSeq")));//外部订单编号，选填!；
// 通过API接口下单，必须传入一个外部接入商的订单编号,该编号与智能营销系统编号一一对应
signMap.put("orderOutNum", objectMap.get("orderSeq"));
qParams.add(new BasicNameValuePair("orderSource", "校园宽带自助受理"));// 订单来源 ，选填
signMap.put("orderSource", "校园宽带自助受理");
qParams.add(new BasicNameValuePair("orderSourceNum", objectMap.get("orderSeq")));// 订单来源单号，选填；与订单来源对应，用于业务上记录订单的来源订单编号
signMap.put("orderSourceNum", (String) objectMap.get("orderSeq"));
qParams.add(new BasicNameValuePair("salePointCode", ""));// 销售点编码，选填
signMap.put("salePointCode", "");
qParams.add(new BasicNameValuePair("personCode", ""));// 人员编码，必填
signMap.put("personCode", "");
qParams.add(new BasicNameValuePair("deliveryProvince", "广东省"));// 配送地址-省，必填
signMap.put("deliveryProvince", "广东省");
qParams.add(new BasicNameValuePair("deliveryCity", "广州市"));// 配送地址-市，必填
signMap.put("deliveryCity", "广州市");
qParams.add(new BasicNameValuePair("deliveryDistrict", addressDistrict));// 配送地址-区，必填
signMap.put("deliveryDistrict", addressDistrict);
qParams.add(new BasicNameValuePair("deliveryAddress", address));// 配送地址-详细地址，必填
signMap.put("deliveryAddress", address);
qParams.add(new BasicNameValuePair("deliveryContact", parameterMap.get("contactName")[0]));// 联系人，必填
signMap.put("deliveryContact", parameterMap.get("contactName")[0]);
qParams.add(new BasicNameValuePair("deliveryContactPhone", parameterMap.get("contactNumber")[0]));// 联系电话，必填
signMap.put("deliveryContactPhone", parameterMap.get("contactNumber")[0]);
qParams.add(new BasicNameValuePair("deliveryContactPhone2", ""));// 联系电话2，选填
signMap.put("deliveryContactPhone2", "");
qParams.add(new BasicNameValuePair("invoiced", "0"));// 是否需要发票，必填
// 0:不需要；1:一次性发票；2:分月发票
signMap.put("invoiced", "0");
qParams.add(new BasicNameValuePair("invoiceTitle", ""));// 发票抬头，若需要发票必填
signMap.put("invoiceTitle", "");
qParams.add(new BasicNameValuePair("invoiceDeliveryAddress", ""));// 电子邮箱，若需要发票必填
signMap.put("invoiceDeliveryAddress", "");
qParams.add(new BasicNameValuePair("deliveryType", "不需配送"));// 发货类型，必填，填写[同德仓发货][不需配送][代理商自行发货]
signMap.put("deliveryType", "不需配送");
qParams.add(new BasicNameValuePair("deliveryCompany", ""));// 配送公司，选填，同德仓发货必填；填写只能填顺丰速运或者如风达或者京东快递或者EMS
signMap.put("deliveryCompany", "");
qParams.add(new BasicNameValuePair("gift", ""));// 礼品，选填，请通过礼品列表接口获取
signMap.put("gift", "");
qParams.add(new BasicNameValuePair("giftNum", ""));// 礼品数量，选填，若礼品填写则必填且为正整数
signMap.put("giftNum", "");
qParams.add(new BasicNameValuePair("acceptPriority", "7"));//受理优先级 为0-10范围内的整数! 选填
signMap.put("acceptPriority", "7");
List<Map<String, Object>> productList = new ArrayList<Map<String, Object>>();// 产品信息
List<Map<String, Object>> inPropertyList = new ArrayList<Map<String, Object>>();// 产品属性
List<Map<String, Object>> paymentList = new ArrayList<Map<String, Object>>();// 销售品信息(费用项)
List<Map<String, String>> addPropertyList = new ArrayList<Map<String, String>>();// 自定义产品属性
// 下单产品
Map<String, Object> productMap = new HashMap<String, Object>();
// 产品(一个订单只能有一种产品且数量为1)
productMap.put("productId", productId);// 产品id,必填，请通过产品列表接口获取
// 产品都必须传一个产品对应的唯一的收费项
Map<String, Object> paymentListMap = new HashMap<String, Object>();
paymentListMap.put("id", "4455");// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap.put("saleName", "校园融合套餐");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap.put("payType", "2");// 缴费方式，
//必填（例：payType：3）1：银行划账2：现金支付3：代理商打款4：穗易付6：支付宝划扣7：货到付款8：装维上门收取9:第三方托收11：代理商代扣
//单宽带
Map<String, Object> paymentListMap2 = new HashMap<String, Object>();
paymentListMap2.put("id", objectMap.get("saleId1"));// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap2.put("saleName", "");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap2.put("payType", "2");// 缴费方式，必填（例：payType：3）3：代理商打款4：穗易付7：货到付款
Map<String, Object> paymentListMap3 = new HashMap<String, Object>();
paymentListMap3.put("id", objectMap.get("saleId2"));// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap3.put("saleName", "");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap3.put("payType", "2");// 缴费方式，
Map<String, Object> paymentListMap4 = new HashMap<String, Object>();
paymentListMap4.put("id", objectMap.get("saleId3"));// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap4.put("saleName", "");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap4.put("payType", "2");// 缴费方式，
Map<String, Object> paymentListMap5 = new HashMap<String, Object>();
paymentListMap5.put("id", objectMap.get("saleId4"));// 收费项ID，选填；请通过销售品列表接口获取，若不填表示终端补收款
paymentListMap5.put("saleName", "");// 销售品名称，选填，若id不填写此项必填写，且只能为终端补收款
paymentListMap5.put("payType", "1");// 缴费方式，
paymentListMap5.put("bank", parameterMap.get("bank")[0]);// 银行名称，若选择银行划账，此项必填
// (中国银行、中国工商银行、中国农业银行、民生银行、招商银行、中信银行、商业银行、广东发展银行
// 光大银行、华夏银行、兴业银行、浦发银行、广州农村商业银行、广州银行、深圳发展银行、交通银行、平安银行、中国建设银行、邮政储蓄)
paymentListMap5.put("bankNumber", parameterMap.get("bankNumber")[0]);// 银行账号，若选择银行划账，此项必填
paymentListMap5.put("bankOwner", parameterMap.get("userName")[0]);// 银行账号持有人，若选择银行划账，此项必填
paymentList.add(paymentListMap);
paymentList.add(paymentListMap2);
paymentList.add(paymentListMap3);
paymentList.add(paymentListMap4);
paymentList.add(paymentListMap5);
productMap.put("payment", paymentList);
// 产品属性 必填主卡号码属性,name=主卡号码,value=11位数字或者随机；
Map<String, Object> inPropertyListMap = new HashMap<String, Object>();
inPropertyListMap.put("name", "主卡号码");
inPropertyListMap.put("value", parameterMap.get("bussnessPhone")[0]);
inPropertyList.add(inPropertyListMap);
productMap.put("inpProperties", inPropertyList);
productList.add(productMap);
// 将对象装换为json字符串
String productJson = JSONArray.fromObject(productList).toString();
try {
qParams.add(new BasicNameValuePair("productJson", URLEncoder.encode(productJson, "UTF-8")));// 产品信息，必填
signMap.put("productJson", URLEncoder.encode(productJson, "UTF-8"));
} catch (UnsupportedEncodingException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);// key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
log.info("---------plaintext---------:" + plaintext);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
//qParams.add(new BasicNameValuePair("sign", SignUtil.exChange(SignUtil.md5EncodeSignature(plaintext))));//签名，必填
//log.info("---------sign---------:" + SignUtil.exChange(SignUtil.md5EncodeSignature(plaintext)));
log.info("---------sign---------:"+sign);
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
log.info("融合下单接口，返回信息:" + httpResult);
resultDataJson = JSONObject.fromObject(httpResult);
} catch (Exception e) {
log.info("融合下单接口接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
/**
* 保存订单到数据库
*/
private void saveOrderInfo(Map<String, String> orderMap,String ORDERSEQ) throws Exception {
log.info("支付操作后保存数据到数据库");
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
OrderView orderView = new OrderView();
orderView.setOrderSeq(ProduceIdUtil.getId()+"");// 订单号码
orderView.setProductName(orderMap.get("productTitle")); // 产品名称
orderView.setOrderSetMeal(orderMap.get("order_set_meal")); // 套餐
orderView.setOrderUniversityName(orderMap.get("order_university_name")); // 学校
orderView.setOrderName(orderMap.get("orderName")); // 姓名
String orderDatetime = orderMap.get("orderDatetime");
orderView.setOrderDate(df.parse(orderDatetime)); // 提交时间
orderView.setStatus(orderMap.get("Status")); // 订单状态
orderView.setOrderRegion(orderMap.get("universityRegion")); // 区域
orderView.setIPay(orderMap.get("ipay")); // 支付平台
orderView.setPayType(orderMap.get("payType")); // 支付方式
orderView.setWebOrderAmount(orderMap.get("prices").replace("元", "")); // 产品价格
orderView.setCustomerId("xyzxyql"); // 接入商
orderView.setOrderPhone(orderMap.get("orderPhone")); // 联系电话
orderView.setOrderNumber(orderMap.get("orderNumber")); // 身份证号码
if (StringUtils.isBlank(orderMap.get("order_customer_student_id"))) {
orderView.setOrderCustomerType("老师"); // 用户类别
} else {
orderView.setOrderCustomerType("学生"); // 用户类别
}
orderView.setOrderCustomerRemarks(orderMap.get("bussnessPhone"));
orderView.setOrderCustomerStudentId(orderMap.get("order_customer_student_id")); // 学生证号
orderView.setOrderCustomerAccount(orderMap.get("order_customer_account")); // 多媒体账号
orderView.setOrderCustomerPwd(orderMap.get("order_customer_pwd")); // 多媒体密码
UserSchool userSchool = userSchoolMapper.selectById(orderMap.get("partner"));
School school = schoolMapper.selectById(userSchool.getSchoolId());
SysUser sysUser = sysUserMapper.selectById(userSchool.getUserId());
if (orderMap.get("upStatus").equals("1")) {
Order order = new Order();
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
uuid = uuid.substring(1, 12);
SimpleDateFormat df2 = new SimpleDateFormat("yyyyMMdd");//设置日期格式
order.setId(uuid);
order.setOrderNumber("YRYM" + df2.format(new Date()) + (int) ((Math.random() * 9 + 1) * 1000));
order.setNetNumber(orderMap.get("order_customer_account"));
order.setNetPassword(orderMap.get("order_customer_pwd"));
order.setUserSchool(orderMap.get("order_university_name"));
order.setHehuorenId(orderMap.get("partner"));
order.setKdOrderId(orderMap.get("orderSeq"));
order.setUserType("3");
order.setBusinessNumber(orderMap.get("bussnessPhone"));
order.setIdentifying(orderMap.get("identifying"));
order.setCustomerName(orderMap.get("orderName"));
order.setOrderStatus("审核中");
order.setContactNumber(orderMap.get("orderPhone"));
order.setIdCard(orderMap.get("orderNumber"));
order.setExpenses(orderMap.get("expenses"));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
order.setCreateTime(new Date());
if (!school.equals(null)) {
order.setHehuorenArea(school.getSubName());
order.setHehuorenSchool(school.getSchoolName());
order.setLzgh(school.getLzgh());
order.setHehuorenName(sysUser.getName());
order.setHehuorenPhone(sysUser.getPhone());
order.setSupervisorName(sysUser.getName());
}
orderMapper.insert(order);
OrderHistory history = new OrderHistory();
history.setOrderId(uuid);
history.setCreateDate(new Date());
history.setStatus("资料已提交");
historyMapper.insert(history);
} else if (orderMap.get("upStatus").equals("2")) {
} else {
Order order = new Order();
String uuid = UUID.randomUUID().toString().replaceAll("-", "");
uuid = uuid.substring(1, 12);
order.setId(uuid);
SimpleDateFormat df2 = new SimpleDateFormat("yyyyMMdd");//设置日期格式
order.setOrderNumber("YRYM" + df2.format(new Date()) + (int) ((Math.random() * 9 + 1) * 1000));
order.setNetNumber(orderMap.get("order_customer_account"));
order.setNetPassword(orderMap.get("order_customer_pwd"));
order.setUserSchool(orderMap.get("order_university_name"));
order.setHehuorenId(orderMap.get("partner"));
order.setKdOrderId(orderMap.get("orderSeq"));
order.setUserType("5");
order.setBusinessNumber("");
order.setCustomerName(orderMap.get("orderName"));
order.setOrderStatus("审核中");
order.setContactNumber(orderMap.get("orderPhone"));
order.setIdCard(orderMap.get("orderNumber"));
order.setExpenses("");
order.setIdentifying(orderMap.get("identifying"));
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
order.setCreateTime(new Date());
if (!school.equals(null)) {
order.setHehuorenArea(school.getSubName());
order.setHehuorenSchool(school.getSchoolName());
order.setLzgh(school.getLzgh());
order.setHehuorenName(sysUser.getName());
order.setHehuorenPhone(sysUser.getPhone());
order.setSupervisorName(sysUser.getName());
}
orderMapper.insert(order);
OrderHistory history = new OrderHistory();
history.setOrderId(uuid);
history.setCreateDate(new Date());
history.setStatus("资料已提交");
historyMapper.insert(history);
}
}
@RequestMapping(value = "getSaleId", method = {RequestMethod.GET, RequestMethod.POST}, produces = "text/plain;charset=UTF-8")
@ResponseBody
private JSONObject getSaleId(String productId, String currentTimeStr) throws Exception {
List<NameValuePair> qParams = new ArrayList<NameValuePair>();
Map<String, String> signMap = new HashMap<String, String>();//待签名参数
//HttpHost proxy = new HttpHost("172.18.101.170", 3128);
RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(500000)
.setConnectTimeout(500000).setConnectionRequestTimeout(500000).build();//.setProxy(proxy)
CloseableHttpClient httpclient = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig)
.build();
HttpEntity entity = null;
HttpPost httpPost = new HttpPost(Constant.ZHANGSHIURL + "query.action");
RequestConfig requestConfig = RequestConfig.copy(defaultRequestConfig).build();
httpPost.setConfig(requestConfig);
qParams.add(new BasicNameValuePair("service", "sale.query"));//api标识，必填
signMap.put("service", "sale.query");
qParams.add(new BasicNameValuePair("userName", Constant.ZHENGSHIAUCCON));//用户名，必填
signMap.put("userName", Constant.ZHENGSHIAUCCON);
qParams.add(new BasicNameValuePair("timeStamp", currentTimeStr));
signMap.put("timeStamp", currentTimeStr);
if (StringUtils.isNotBlank(productId)) {
qParams.add(new BasicNameValuePair("productId", productId));//产品ID
signMap.put("productId", productId);
}
List<String> keys = new ArrayList<String>();
keys.addAll(signMap.keySet());
Collections.sort(keys);//key按字符串升序
String value, plaintext = "";
for (String key : keys) {
value = signMap.get(key);
plaintext = plaintext.concat(value);
}
plaintext = plaintext.concat(Constant.ZHANGSHIKEY);
String sign = MD5Utils.md5(plaintext).toUpperCase();//md5加密
qParams.add(new BasicNameValuePair("sign", sign));//签名，必填
//qParams.add(new BasicNameValuePair("sign", SignUtil.exChange(SignUtil.md5EncodeSignature(plaintext))));//签名，必填
JSONObject resultDataJson = null;
try {
httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=utf-8");
httpPost.setEntity(new UrlEncodedFormEntity(qParams, "UTF-8"));
log.info("提交参数:" + EntityUtils.toString(httpPost.getEntity(), "UTF-8"));
HttpResponse response = httpclient.execute(httpPost);
entity = response.getEntity();
String httpResult = EntityUtils.toString(entity, "UTF-8");
log.info("返回信息:" + httpResult);
resultDataJson = JSONObject.fromObject(httpResult);
} catch (Exception e) {
log.info("---接口异常");
e.printStackTrace();
} finally {
httpPost.releaseConnection();
}
return resultDataJson;
}
/**
* 查询套餐信息（暂时弃用）
* @param partner
* @return
*/
@ResponseBody
@RequestMapping(value = "getTaoCanByType", method = RequestMethod.POST)
public ResponseData<Map<String, Object>> getTaoCanByType(String partner) {
Wrapper<Product> productWrapper = new EntityWrapper<>();
productWrapper.setSqlSelect(" product_id,product_title,product_creater,product_last_update_time,product_create_time," +
"product_region,product_introduction_pic1,product_meal_price,product_set_meal_introduction,product_introduction," +
"product_state,product_university,identifying,product_rf2,product_school_abbreviated,product_price,product_meal," +
"product_rate,product_introduction_pic2,product_introduction_pic3,product_introduction_pic4," +
"product_introduction_pic5,university_id ");
if (StringUtils.isNotBlank(partner)){
productWrapper.addFilter("product_university = '"+partner+"'");
}
Map<String, Object> productMap = productMapper.selectMaps(productWrapper).get(0);
if (productMap == null || productMap.size() == 0) {
return ResponseData.error("套餐不存在！");
}
/*String university_id = productMap.get("university_id").toString();
Wrapper<UniversityInfo> universityInfoWrapper = new EntityWrapper<>();
universityInfoWrapper.setSqlSelect(" * ");
if(StringUtils.isNotBlank(university_id)){
universityInfoWrapper.addFilter("university_id = '"+university_id+"'");
}
Map<String, Object> uniInfoMap = universityInfoMapper.selectMaps(universityInfoWrapper).get(0);
*/
Map<String, Object> objMap = new HashMap<>();
objMap.put("productMap",productMap);
/*objMap.put("uniInfoMap",uniInfoMap);*/
return ResponseData.success(objMap);
}
}
old-user/src/main/java/com/winsun/controller/PackageUpgradeController.java
......@@ -11,6 +11,7 @@ import com.winsun.constant.OrderStatus;
import com.winsun.constant.UserType;
import com.winsun.mapper.*;
import com.winsun.utils.IDCardUtil;
import com.winsun.utils.ProduceIdUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
......@@ -329,10 +330,7 @@ public class PackageUpgradeController extends BaseController {
order.setBusinessPackage(businessPackage);
order.setUserId(userId);
order.setUserType(UserType.OLDCUSTOMER.getId());
SimpleDateFormat yyyyMMdd = new SimpleDateFormat("yyyyMMdd");
String format = yyyyMMdd.format(date);
String s = String.valueOf((int) ((Math.random() * 9 + 1) * 1000));
order.setOrderNumber("YRYM" + format + s);
order.setOrderNumber("YRYM" + ProduceIdUtil.getId());
order.setHehuorenArea(sysUser.getSubstName());
order.setHehuorenName(sysUser.getName());
String schoolId = appMapper.selectSchoolId(partner);
......@@ -343,14 +341,14 @@ public class PackageUpgradeController extends BaseController {
order.setHehuorenSchool(schoolName);
order.setHehuorenPhone(sysUser.getPhone());
Integer insert = orderMapper.insert(order);
appMapper.inserOrderHis(id, "下单成功", date, sysUser.getName());
appMapper.inserOrderHis(id, "下单成功", date,customerName);
// MessageUtil.sent(contactNumber,"4","");
if (StringUtils.isNotBlank(mark)) {
String uuid1 = UUID.randomUUID().toString();
String id1 = uuid1.split("-")[0] + uuid1.split("-")[1];
String s1 = String.valueOf((int) ((Math.random() * 9 + 1) * 1000));
order.setId(id1);
order.setOrderNumber("YRYM" + format + s1);
order.setOrderNumber("YRYM" + ProduceIdUtil.getId());
order.setUserType(UserType.YCTK.getId());
order.setAddress(addRess);
order.setBusinessPackage("天翼羊城通手机卡业务");
......@@ -365,7 +363,7 @@ public class PackageUpgradeController extends BaseController {
yangChengTong.setCustomerPhone(businessNumber);
yangChengTong.setCustomerName(customerName);
insert += yangChengTongrMapper.insert(yangChengTong);
appMapper.inserOrderHis(id1, "下单成功", date, sysUser.getName());
appMapper.inserOrderHis(id1, "下单成功", date, customerName);
return ResponseData.success(id + ":" + id1, "下单成功！");
}
if (insert == 1) {
......
order/src/main/java/com/winsun/bean/Step.java 0 → 100644
package com.winsun.bean;
import com.baomidou.mybatisplus.annotations.TableId;
import com.baomidou.mybatisplus.annotations.TableName;
import lombok.Data;
import java.util.Date;
/**
* 流程步骤
* @author Liph
* @datetime 2020-04-20/4/1 10:58
*/
@Data
@TableName("sys_step")
public class Step {
@TableId
private String id;
/**
* 流程路径（主要用于队列执行的时候用）
*/
private String path;
/**
* 步骤名称
*/
private String name;
/**
* 步骤描述
*/
private String desc;
/**
* 步骤所关联的表单
*/
private String formId;
/**
* 创建时间
*/
private Date createTime;
/**
* 流程步骤对应到的接口ID标识（例如全包类名）
*/
private String interfaceId;
/**
* 下一步骤的流程ID主键
* 主要描述情况 A，不归属完成
* 如果当前数据的值为空（null or ""）代表当前流程没 A 分支
*/
private String selectA;
/**
* 选择情况A的时候，更新工单的状态值
*/
private String selectAval;
/**
* 下一步骤的流程ID主键
* 主要描述情况 B，不归属完成
* 如果当前数据的值为空（null or ""）代表当前流程没 B 分支
*/
private String selectB;
/**
* 选择情况B的时候，更新工单的状态值
*/
private String slectBval;
/**
* 下一步骤的流程ID主键
* 主要描述当前流程完成
* 如果当前数据的值为空（null or ""）当做下一步结束处理（也就是当前节点就是流程终点）
*/
private String selectNext;
/**
* 选择当前步骤完成，工单更新的状态值
*/
private String selectNextVal;
}
order/src/main/java/com/winsun/constant/FormState.java 0 → 100644
package com.winsun.constant;
/**
* @author Liph
* @datetime 2020-04-20/4/2 17:28
*/
public enum FormState {
/**
* 表单状态枚举
*/
ENABLE("0", "禁用"), DISABLE("10000", "启用");
FormState(String id, String name) {
this.id = id;
this.name = name;
}
private String id;
private String name;
public String getId() {
return id;
}
public String getName() {
return name;
}
/**
* 根据ID获取状态枚举
* @param id 状态ID
* @return
*/
public static FormState findById(String id) {
for(FormState state : values()) {
if(state.getId().equals(id)) {
return state;
}
}
return null;
}
}
order/src/main/java/com/winsun/controller/FormController.java 0 → 100644
package com.winsun.controller;
import com.winsun.auth.core.common.model.ResponseData;
import com.winsun.bean.Form;
import com.winsun.mapper.FormMapper;
import org.springframework.beans.factory.annotation.Autowired;
/**
* 用于作为表单的创建、信息返回等使用
* @author Liph
* @datetime 2020-04-20/4/2 17:17
*/
public class FormController {
private static FormMapper formMapper;
@Autowired
public FormController(FormMapper formMapper) {
FormController.formMapper = formMapper;
}
public ResponseData<Form> list() {
return ResponseData.error(null);
}
public ResponseData<Form> creat() {
return ResponseData.error(null);
}
public ResponseData<Form> modify() {
return ResponseData.error(null);
}
public ResponseData<Form> delete() {
return ResponseData.error(null);
}
public ResponseData<Form> disable() {
return ResponseData.error(null);
}
public ResponseData<Form> enable() {
return ResponseData.error(null);
}
}
order/src/main/java/com/winsun/mapper/FormMapper.java 0 → 100644
package com.winsun.mapper;
import com.baomidou.mybatisplus.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
/**
* @author Liph
* @datetime 2020-04-20/4/2 17:26
*/
@Mapper
public interface FormMapper extends BaseMapper<FormMapper> {
}
pom.xml
......@@ -26,7 +26,7 @@
<parent>
<groupId>com.winsun.framework</groupId>
<artifactId>winsun-parent</artifactId>
<version>0.1.52</version>
<version>0.1.57</version>
</parent>
<properties>
......
service-manager/src/main/java/com/winsun/controller/ProductController.java
......@@ -106,6 +106,7 @@ public class ProductController extends BaseController {
dataMapping.put("product_meal", pro.getProductMeal());
dataMapping.put("product_title", pro.getProductTitle());
dataMapping.put("product_university", pro.getProductUniversity());
dataMapping.put("university_id", pro.getUniversityId());
dataMapping.put("product_price", pro.getProductPrice());
dataMapping.put("product_region", pro.getProductRegion());
dataMapping.put("product_rate", pro.getProductRate());
......
service-manager/src/main/java/com/winsun/controller/SchoolManagementController.java
......@@ -46,216 +46,215 @@ public class SchoolManagementController extends BaseController {
private static SchoolMapper schoolMapper;
private static SchoolPackageMapper schoolPackageMapper;
private static SchoolPackageMapper schoolPackageMapper;
private static PackageMapper packageMapper;
private static PackageMapper packageMapper;
private static ProductMapper productMapper;
private static ProductMapper productMapper;
// 默认路径
private static String DEFAULTPATH = "images/schoolPartner/";
//默认路径
private static String DEFAULTPATH="images/schoolPartner/";
private static String FILENAME = ".jpg";
@Autowired
public SchoolManagementController(SchoolMapper schoolMapper, SchoolPackageMapper schoolPackageMapper,
PackageMapper packageMapper, ProductMapper productMapper) {
SchoolManagementController.schoolMapper = schoolMapper;
SchoolManagementController.schoolPackageMapper = schoolPackageMapper;
SchoolManagementController.packageMapper = packageMapper;
SchoolManagementController.productMapper = productMapper;
}
private static String FILENAME=".jpg";
@Permission(menuname = "添加学校信息", value = "insert", method = RequestMethod.POST)
public ResponseData<String> insertSchool(@RequestParam("subName") String subName,
@RequestParam("schoolName") String schoolName, @RequestParam("netId") String netId,
@RequestParam("lzgh") String lzgh, @RequestParam("bandproductId") String bandproductId,
@RequestParam("netPhone") String netPhone, @RequestParam("isShowband") String isShowband,
@RequestParam("isShowrh") String isShowrh, @RequestParam("isRecv") String isRecv,
@RequestParam("chosePages") String chosePages) {
@Autowired
public SchoolManagementController(SchoolMapper schoolMapper, SchoolPackageMapper schoolPackageMapper,PackageMapper packageMapper,ProductMapper productMapper) {
SchoolManagementController.schoolMapper = schoolMapper;
SchoolManagementController.schoolPackageMapper = schoolPackageMapper;
SchoolManagementController.packageMapper = packageMapper;
SchoolManagementController.productMapper = productMapper;
}
School school = new School();
school.setBandproductId(bandproductId);
if (StringUtils.isNotBlank(isRecv)) {
school.setIsRecv(Integer.valueOf(isRecv));
}
@Permission(menuname = "添加学校信息", value = "insert", method = RequestMethod.POST)
public ResponseData<String> insertSchool(@RequestParam("subName") String subName,@RequestParam("schoolName") String schoolName,@RequestParam("netId") String netId,
@RequestParam("lzgh") String lzgh,@RequestParam("bandproductId") String bandproductId,@RequestParam("netPhone") String netPhone,
@RequestParam("isShowband") String isShowband,@RequestParam("isShowrh") String isShowrh,@RequestParam("isRecv") String isRecv,
@RequestParam("chosePages") String chosePages,@RequestParam("networkCode") String networkCode,@RequestParam("networkName") String networkName) {
school.setNetId(netId);
school.setLzgh(lzgh);
school.setSchoolName(schoolName);
school.setSubName(subName);
school.setIsShowband(isShowband);
school.setIsShowrh(isShowrh);
if (StringUtils.isNotBlank(netPhone)) {
school.setNetPhone(Integer.valueOf(netPhone));
}
Integer insert = schoolMapper.insert(school);
School school = new School();
school.setBandproductId(bandproductId);
if (StringUtils.isNotBlank(isRecv)){
school.setIsRecv(Integer.valueOf(isRecv));
}
school.setNetId(netId);
school.setLzgh(lzgh);
school.setSchoolName(schoolName);
school.setSubName(subName);
school.setIsShowband(isShowband);
school.setIsShowrh(isShowrh);
school.setNetworkCode(networkCode);
school.setNetworkName(networkName);
if (StringUtils.isNotBlank(netPhone)){
school.setNetPhone(Integer.valueOf(netPhone));
}
Integer insert = schoolMapper.insert(school);
// 插入中间表
if (StringUtils.isNotBlank(chosePages)) {
String[] split = chosePages.split(",");
if (split.length <= 0) {
return ResponseData.success("添加成功！");
}
for (String s : split) {
SchoolPackage schoolPackage = new SchoolPackage();
schoolPackage.setSchoolId(String.valueOf(school.getId()));
schoolPackage.setPackageId(s);
schoolPackageMapper.insert(schoolPackage);
}
}
if (insert == 1) {
EntityWrapper<School> schoolwrapper = new EntityWrapper<>();
schoolwrapper.eq("id", school.getId());
String backgroundpath = "/" + DEFAULTPATH + school.getId() + FILENAME;
schoolMapper.updateForSet("service_qrcode ='" + backgroundpath + "'", schoolwrapper);
log.info("学校信息新增完毕,id: {}", school.getId());
return ResponseData.success("添加成功！");
}
return ResponseData.error("添加失败！");
//插入中间表
if (StringUtils.isNotBlank(chosePages)){
String[] split = chosePages.split(",");
if (split.length<=0) {
return ResponseData.success("添加成功！");
}
for (String s : split) {
SchoolPackage schoolPackage = new SchoolPackage();
schoolPackage.setSchoolId( String.valueOf(school.getId()));
schoolPackage.setPackageId(s);
schoolPackageMapper.insert(schoolPackage);
}
}
if (insert==1){
EntityWrapper<School> schoolwrapper = new EntityWrapper<>();
schoolwrapper.eq("id",school.getId());
String backgroundpath= "/"+DEFAULTPATH+ school.getId()+FILENAME;
schoolMapper.updateForSet("service_qrcode ='"+backgroundpath+"'",schoolwrapper);
log.info("学校信息新增完毕,id: {}",school.getId());
return ResponseData.success("添加成功！");
}
return ResponseData.error("添加失败！");
}
}
@Permission(menuname = "删除學校信息", value = "hidestatus", method = RequestMethod.POST)
public ResponseData<String> deleteSchool(@RequestParam("id") String id, @RequestParam("status") int status) {
@Permission(menuname = "删除學校信息", value = "hidestatus", method = RequestMethod.POST)
public ResponseData<String> deleteSchool(@RequestParam("id") String id,@RequestParam("status") int status) {
Integer integer = schoolMapper.updateForSet("status=" + status, new EntityWrapper<School>().eq("id", id));
if (integer == 1) {
return ResponseData.success("修改成功！");
}
return ResponseData.error("修改失败");
Integer integer = schoolMapper.updateForSet("status=" + status, new EntityWrapper<School>().eq("id", id));
if (integer==1){
return ResponseData.success("修改成功！");
}
return ResponseData.error("修改失败");
}
}
/**
* @param id
* @param subName 县分
* @param schoolName 学校
* @param netId 网点id
* @param lzgh 揽装工号
* @param bandproductId 单宽id
* @param netPhone 购机
* @param isShowband 显示宽带
* @param isShowrh 融合
* @param isRecv 收到电信卡
* @param chosePages 套餐id
* @return
*/
@Permission(menuname = "修改学校信息", value = "update", method = RequestMethod.POST)
public ResponseData<String> updateSchool(@RequestParam("id") String id, @RequestParam("subName") String subName,
@RequestParam("schoolName") String schoolName, @RequestParam("netId") String netId,
@RequestParam("lzgh") String lzgh, @RequestParam("bandproductId") String bandproductId,
@RequestParam("netPhone") String netPhone, @RequestParam("isShowband") String isShowband,
@RequestParam("isShowrh") String isShowrh, @RequestParam("isRecv") String isRecv,
@RequestParam("chosePages") String chosePages) {
/**
*@param id
* @param subName 县分
* @param schoolName 学校
* @param netId 网点id
* @param lzgh 揽装工号
* @param bandproductId 单宽id
* @param netPhone 购机
* @param isShowband 显示宽带
* @param isShowrh 融合
* @param isRecv 收到电信卡
* @param chosePages 套餐id
* @return
*/
@Permission(menuname = "修改学校信息", value = "update", method = RequestMethod.POST)
public ResponseData<String> updateSchool(@RequestParam("id") String id,@RequestParam("subName") String subName,@RequestParam("schoolName") String schoolName,@RequestParam("netId") String netId,
@RequestParam("lzgh") String lzgh,@RequestParam("bandproductId") String bandproductId,@RequestParam("netPhone") String netPhone,@RequestParam("isShowband") String isShowband,
@RequestParam("isShowrh") String isShowrh,@RequestParam("isRecv") String isRecv,@RequestParam("chosePages") String chosePages,
@RequestParam("networkCode") String networkCode,@RequestParam("networkName") String networkName) {
Wrapper<School> wrapper = new EntityWrapper<>();
wrapper.eq("id", id);
Map<String, Object> dataMapping = new HashMap<>();
dataMapping.put("sub_name", subName);
dataMapping.put("school_name", schoolName);
dataMapping.put("lzgh", lzgh);
dataMapping.put("net_id", netId);
dataMapping.put("is_recv", isRecv);
dataMapping.put("net_phone", netPhone);
dataMapping.put("bandproduct_id", bandproductId);
dataMapping.put("is_showband", isShowband);
dataMapping.put("is_showrh", isShowrh);
schoolMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping), wrapper);
// 插入学校与套餐中间表数据
if (StringUtils.isNotBlank(chosePages)) {
String[] split = chosePages.split(",");
if (split.length <= 0) {
return ResponseData.success("修改完毕！");
}
EntityWrapper<SchoolPackage> schoolPackagewrapper = new EntityWrapper<>();
schoolPackagewrapper.eq("school_id", id);
schoolPackageMapper.delete(schoolPackagewrapper);
for (String s : split) {
SchoolPackage schoolPackage = new SchoolPackage();
schoolPackage.setSchoolId(id);
schoolPackage.setPackageId(s);
schoolPackageMapper.insert(schoolPackage);
}
}
return ResponseData.success("修改完毕！");
}
Wrapper<School> wrapper = new EntityWrapper<>();
wrapper.eq("id",id);
Map<String, Object> dataMapping = new HashMap<>();
dataMapping.put("sub_name", subName);
dataMapping.put("school_name", schoolName);
dataMapping.put("lzgh", lzgh);
dataMapping.put("net_id", netId);
dataMapping.put("is_recv", isRecv);
dataMapping.put("net_phone", netPhone);
dataMapping.put("bandproduct_id", bandproductId);
dataMapping.put("is_showband", isShowband);
dataMapping.put("is_showrh", isShowrh);
dataMapping.put("network_code", networkCode);
dataMapping.put("network_name", networkName);
schoolMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(dataMapping), wrapper);
//插入学校与套餐中间表数据
if (StringUtils.isNotBlank(chosePages)){
String[] split = chosePages.split(",");
if (split.length<=0) {
return ResponseData.success("修改完毕！");
}
EntityWrapper<SchoolPackage> schoolPackagewrapper = new EntityWrapper<>();
schoolPackagewrapper.eq("school_id",id);
schoolPackageMapper.delete(schoolPackagewrapper);
for (String s : split) {
SchoolPackage schoolPackage = new SchoolPackage();
schoolPackage.setSchoolId(id);
schoolPackage.setPackageId(s);
schoolPackageMapper.insert(schoolPackage);
}
}
return ResponseData.success("修改完毕！");
}
/**
*
* @param subName
* @param status
* @param schoolName
* @param pageIndex
* @param pageSize
* @return
*/
@Permission(menuname = "查询学校信息", value = "findByList", method = RequestMethod.POST)
public ResponseData<Page<Map<String, Object>>> listSchool(@RequestParam("subName") String subName,
@RequestParam("status") String status, @RequestParam("schoolName") String schoolName,
@RequestParam(name = "pageNo", required = false) int pageIndex,
@RequestParam(name = "pageSize", required = false) int pageSize) {
ShiroUser user = getShiroUser();
if (!user.getRoleNames().stream().anyMatch(roleName -> StringUtils.equalsAny(roleName, "超级管理员"))) {
return ResponseData.error("无数据权限");
}
Wrapper<School> wrapper = new EntityWrapper();
wrapper.like(StringUtils.isNotBlank(schoolName), "school_name", schoolName, SqlLike.DEFAULT);
wrapper.eq(StringUtils.isNotBlank(subName), "sub_name", subName);
wrapper.eq(StringUtils.isNotBlank(status), "status", status);
Page<Map<String, Object>> page = new Page<>(pageIndex, pageSize);
List<Map<String, Object>> maps = schoolMapper.selectMapsPage(page, wrapper);
// 查询县分列表
Wrapper<School> wrapperSubName = new EntityWrapper();
wrapperSubName.setSqlSelect("sub_name as subNameList").groupBy("sub_name");
List<Map<String, Object>> selectMaps = schoolMapper.selectMaps(wrapperSubName);
EntityWrapper<Package> packagewrapper = new EntityWrapper<>();
packagewrapper.setSqlSelect("id,package_name as packageName");
List<Map<String, Object>> packageselectMaps = packageMapper.selectMaps(packagewrapper);
// 查询单宽学校名称
Wrapper<Product> productwrapper = new EntityWrapper();
productwrapper.setSqlSelect("product_id as productId,product_university as ProductUniversity");
productwrapper.eq("product_state", "0");
List<Map<String, Object>> products = productMapper.selectMaps(productwrapper);
// 存放县分下拉列表和单宽学校名称下拉列表
if (!CollectionUtils.isEmpty(maps)) {
maps.get(0).put("subNameList", selectMaps);
maps.get(0).put("packageName", packageselectMaps);
maps.get(0).put("products", products);
}
page.setRecords(maps);
return ResponseData.success(page, "查询完毕！");
}
/**
*
* @param subName
* @param status
* @param schoolName
* @param pageIndex
* @param pageSize
* @return
*/
@Permission(menuname = "查询学校信息", value = "findByList", method = RequestMethod.POST)
public ResponseData<Page<Map<String,Object>>> listSchool(@RequestParam("subName") String subName, @RequestParam("status") String status,
@RequestParam("schoolName") String schoolName, @RequestParam(name = "pageNo", required = false) int pageIndex,
@RequestParam(name = "pageSize", required = false) int pageSize,
@RequestParam("networkName") String networkName) {
ShiroUser user = getShiroUser();
if (!user.getRoleNames().stream().anyMatch(roleName -> StringUtils.equalsAny(roleName, "超级管理员"))) {
return ResponseData.error("无数据权限");
}
Wrapper<School> wrapper = new EntityWrapper();
wrapper.like(StringUtils.isNotBlank(networkName), "network_name", networkName, SqlLike.DEFAULT);
wrapper.like(StringUtils.isNotBlank(schoolName), "school_name", schoolName, SqlLike.DEFAULT);
wrapper.eq(StringUtils.isNotBlank(subName), "sub_name", subName);
wrapper.eq(StringUtils.isNotBlank(status), "status", status);
Page<Map<String,Object>> page = new Page<>(pageIndex, pageSize);
List<Map<String, Object>> maps = schoolMapper.selectMapsPage(page, wrapper);
//查询县分列表
Wrapper<School> wrapperSubName = new EntityWrapper();
wrapperSubName.setSqlSelect("sub_name as subNameList").groupBy("sub_name");
List<Map<String, Object>> selectMaps = schoolMapper.selectMaps(wrapperSubName);
EntityWrapper<Package> packagewrapper = new EntityWrapper<>();
packagewrapper.setSqlSelect("id,package_name as packageName");
List<Map<String, Object>> packageselectMaps = packageMapper.selectMaps(packagewrapper);
//查询单宽学校名称
Wrapper<Product> productwrapper = new EntityWrapper();
productwrapper.setSqlSelect("product_id as productId,product_university as ProductUniversity");
productwrapper.eq("product_state", "0");
List<Map<String, Object>> products = productMapper.selectMaps(productwrapper);
//存放县分下拉列表和单宽学校名称下拉列表
if (!CollectionUtils.isEmpty(maps)){
maps.get(0).put("subNameList",selectMaps);
maps.get(0).put("packageName",packageselectMaps);
maps.get(0).put("products",products);
}
page.setRecords(maps);
return ResponseData.success(page, "查询完毕！");
}
@Permission(menuname = "编辑套餐选择回显数据", value = "choosepages", method = RequestMethod.POST)
public ResponseData<Map<String, Object>> editdisplay(@RequestParam("id") String id) {
HashMap<String, Object> hashMap = new HashMap<>();
EntityWrapper<SchoolPackage> schoolPackagewrapper = new EntityWrapper<>();
schoolPackagewrapper.eq("school_id", id);
List<SchoolPackage> schoolPackages = schoolPackageMapper.selectList(schoolPackagewrapper);
ArrayList<String> arrayList = new ArrayList<>();
schoolPackages.forEach(val -> {
arrayList.add(val.getPackageId());
});
hashMap.put("choosepages", arrayList);
return ResponseData.success(hashMap, "查询完毕！");
}
@Permission(menuname = "编辑套餐选择回显数据", value = "choosepages", method = RequestMethod.POST)
public ResponseData<Map<String,Object>> editdisplay(@RequestParam("id") String id) {
HashMap<String, Object> hashMap = new HashMap<>();
EntityWrapper<SchoolPackage> schoolPackagewrapper = new EntityWrapper<>();
schoolPackagewrapper.eq("school_id",id);
List<SchoolPackage> schoolPackages = schoolPackageMapper.selectList(schoolPackagewrapper);
ArrayList<String> arrayList = new ArrayList<>();
schoolPackages.forEach(val->{
arrayList.add(val.getPackageId());
});
hashMap.put("choosepages",arrayList);
return ResponseData.success(hashMap, "查询完毕！");
}
@Permission(menuname = "上传二维码", value = "qrcodeUpload", method = RequestMethod.POST)
public ResponseData<String> xiaotuUpload(@RequestParam(value = "file") MultipartFile file,
@RequestParam(value = "id", required = false) String id) {
String backgroundpath = FilePath.BACKGROUNDIMG.getValue() + "/" + DEFAULTPATH;
boolean makefile = FileUtil.makefile(backgroundpath, file, id + FILENAME);
Wrapper<School> wrapper = new EntityWrapper<>();
wrapper.eq("id", id);
Map<String, Object> map = new HashMap<>();
map.put("service_qrcode", backgroundpath + id + FILENAME);
Integer integer = schoolMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(map), wrapper);
if (integer != 1) {
return ResponseData.error("上传失败！");
}
return ResponseData.success("上传成功");
}
@Permission(menuname = "上传二维码", value = "qrcodeUpload", method = RequestMethod.POST)
public ResponseData<String>xiaotuUpload(@RequestParam(value = "file") MultipartFile file, @RequestParam(value = "id",required = false) String id) {
String backgroundpath= FilePath.BACKGROUNDIMG.getValue()+"/"+DEFAULTPATH;
boolean makefile = FileUtil.makefile(backgroundpath, file,id+FILENAME);
Wrapper<School> wrapper = new EntityWrapper<>();
wrapper.eq("id",id);
Map<String, Object> map = new HashMap<>();
map.put("service_qrcode",backgroundpath+id+FILENAME);
Integer integer = schoolMapper.updateForSet(MyBatisPlusUpdateUtils.toUpdateSet(map), wrapper);
if (integer!=1){
return ResponseData.error("上传失败！");
}
return ResponseData.success("上传成功" );
}
@Permission(menuname = "获取县分下拉列表", value = "substList", method = RequestMethod.POST)
public ResponseData<List<Map<String, Object>>> substList() {
......
service-manager/src/main/java/com/winsun/controller/UniversityInfoController.java
......@@ -18,10 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.sql.Timestamp;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
/**
* 大学宽带管理
......@@ -133,4 +130,16 @@ public class UniversityInfoController extends BaseController {
page.setRecords(universitys);
return ResponseData.success(page, "查询成功！");
}
/**
* 宽带适用学校
* @return
*/
@Permission(menuname = "单宽学校名称", value = "universitySchool", method = RequestMethod.POST)
public ResponseData< List<UniversityInfo>> universitySchool(){
Wrapper<UniversityInfo> wrapper = new EntityWrapper();
List<UniversityInfo> universityInfos = universityInfoMapper.selectList(wrapper);
return ResponseData.success(universityInfos);
}
}
service-manager/src/main/java/com/winsun/controller/supervisorController.java
......@@ -158,9 +158,9 @@ public class supervisorController extends BaseController {
wrapper.eq("id", orderId);
Order order = orderMapper.selectById(orderId);
Map<String, Object> dataMapping = new HashMap<>();
int xb = order.getXbType();
String xb = order.getXbType();
if ("0".equals(type)) {
if (xb == 1) {
if ("1".equals(xb)) {
dataMapping.put("order_status", "待配送");
dataMapping.put("send_type", "快递");
} else {
......@@ -169,7 +169,7 @@ public class supervisorController extends BaseController {
}
}
if ("1".equals(type)) {
if (xb == 1) {
if ("1".equals(xb)) {
dataMapping.put("order_status", "待活体");
dataMapping.put("send_type", "送货上门");
} else {
......@@ -272,8 +272,8 @@ public class supervisorController extends BaseController {
Wrapper wrapper = new EntityWrapper<>();
wrapper.eq("id", orderId);
Map<String, Object> dataMapping = new HashMap<>();
int xbType = order.getXbType();
if (xbType == 1) {
String xbType = order.getXbType();
if ("1".equals(xbType)) {
dataMapping.put("order_status", "待活体");
} else {
dataMapping.put("order_status", "已完成");
......
service-manager/src/main/resources/application.yml
......@@ -17,6 +17,8 @@ server:
uri-encoding: UTF-8
max-threads: 200
max-connections: 2000
jetty:
max-http-post-size: 1000000
winsun:
app:
version: @project.version@
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment