package com.stylefeng.guns.modular.system.controller;
|
|
|
import com.alibaba.druid.support.json.JSONUtils;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.mapper.EntityWrapper;
|
import com.fasterxml.jackson.core.JsonProcessingException;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.github.pagehelper.PageHelper;
|
import com.github.pagehelper.PageInfo;
|
import com.stylefeng.guns.core.base.tips.ErrorTip;
|
import com.stylefeng.guns.core.common.constant.JwtConstants;
|
import com.stylefeng.guns.core.common.exception.BizExceptionEnum;
|
import com.stylefeng.guns.core.exception.GunsException;
|
import com.stylefeng.guns.core.shiro.ShiroKit;
|
import com.stylefeng.guns.core.util.DateUtil;
|
import com.stylefeng.guns.modular.system.dto.QuestionDto;
|
import com.stylefeng.guns.modular.system.model.*;
|
import com.stylefeng.guns.modular.system.service.ITDeviceService;
|
import com.stylefeng.guns.modular.system.service.ITUserDataService;
|
import com.stylefeng.guns.modular.system.service.ITUserDateDataService;
|
import com.stylefeng.guns.modular.system.service.IUserService;
|
import com.stylefeng.guns.modular.system.util.*;
|
import io.swagger.annotations.ApiImplicitParam;
|
import io.swagger.annotations.ApiImplicitParams;
|
import io.swagger.annotations.ApiOperation;
|
import org.apache.poi.ss.formula.functions.T;
|
import org.apache.poi.ss.usermodel.Cell;
|
import org.apache.poi.ss.usermodel.Row;
|
import org.apache.poi.ss.usermodel.Sheet;
|
import org.apache.poi.ss.usermodel.Workbook;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Controller;
|
import org.springframework.web.bind.annotation.*;
|
import org.springframework.web.multipart.MultipartFile;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.io.InputStream;
|
import java.text.ParseException;
|
import java.text.SimpleDateFormat;
|
import java.time.LocalDate;
|
import java.time.LocalDateTime;
|
import java.time.LocalTime;
|
import java.time.ZoneId;
|
import java.time.temporal.ChronoUnit;
|
import java.util.*;
|
import java.util.regex.Matcher;
|
import java.util.regex.Pattern;
|
import java.util.stream.Collectors;
|
|
@Controller
|
public class AppController {
|
|
@Autowired
|
private IUserService userService;
|
@Autowired
|
private RedisService redisService;
|
|
@ResponseBody
|
@PostMapping("/api/question")
|
@ApiOperation(value = "填写问卷调查", tags = {"App接口"}, notes = "")
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R queryHomeData(HttpServletRequest request, @RequestBody QuestionDto questionDto) throws JsonProcessingException {
|
Integer uid = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
User user = userService.selectById(uid);
|
ObjectMapper mapper = new ObjectMapper();
|
// 将TUserData数组转换为JSON字符串
|
String jsonInString = mapper.writeValueAsString(questionDto);
|
|
user.setQuestion(jsonInString);
|
userService.updateById(user);
|
return R.ok("填写成功");
|
}
|
|
@Autowired
|
private ITDeviceService deviceService;
|
@ResponseBody
|
@PostMapping("/api/checkeq")
|
@ApiOperation(value = "判断当前用户是否绑定硬件", tags = {"App接口"}, notes = "")
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R checkeq(HttpServletRequest request){
|
Integer uid = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
|
List<TDevice> bindId = deviceService.selectList(new EntityWrapper<TDevice>().eq("bindId", uid));
|
if (bindId.isEmpty()){
|
return R.fail("当前用户暂未绑定设备");
|
}
|
|
return R.ok(bindId.get(0));
|
}
|
|
|
@ResponseBody
|
@PostMapping("/api/unbind")
|
@ApiOperation(value = "解绑", tags = {"App接口"}, notes = "")
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R unbind(HttpServletRequest request){
|
Integer uid = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
|
List<TDevice> bindId = deviceService.selectList(new EntityWrapper<TDevice>().eq("bindId", uid));
|
|
for (TDevice tDevice : bindId) {
|
deviceService.deleteById(tDevice.getId());
|
}
|
|
return R.ok();
|
}
|
|
@ResponseBody
|
@PostMapping("/api/checkques")
|
@ApiOperation(value = "判断当前用户信息", tags = {"App接口"}, notes = "")
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R<User> checkques(HttpServletRequest request){
|
Integer uid = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
|
User user = userService.selectById(uid);
|
|
return R.ok(user);
|
}
|
|
@ResponseBody
|
@PostMapping("/api/bind")
|
@ApiOperation(value = "绑定设备", tags = {"App接口"}, notes = "")
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R bind(HttpServletRequest request, @RequestBody TDevice device){
|
Integer uid = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
device.setBindId(uid);
|
if (deviceService.selectList(new EntityWrapper<TDevice>().eq("mac", device.getMac())).isEmpty()) {
|
device.setBindId(uid);
|
device.setBindTime(new Date());
|
deviceService.insert(device);
|
}else {
|
TDevice serNum = deviceService.selectOne(new EntityWrapper<TDevice>().eq("serNum", device.getSerNum()));
|
serNum.setBindId(uid);
|
serNum.setBindTime(new Date());
|
deviceService.updateById(serNum);
|
}
|
return R.ok();
|
}
|
|
@PostMapping("/api/changePwd")
|
@ApiOperation(value = "修改密码", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R changePwd(@RequestParam String oldPwd, @RequestParam String newPwd, @RequestParam String rePwd,HttpServletRequest request) {
|
if (!newPwd.equals(rePwd)) {
|
// throw new GunsException(BizExceptionEnum.TWO_PWD_NOT_MATCH);
|
return R.fail("两次输入密码不一致");
|
}
|
Integer userId = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
User user = userService.selectById(userId);
|
String oldMd5 = ShiroKit.md5(oldPwd, user.getSalt());
|
if (user.getPassword().equals(oldMd5)) {
|
String newMd5 = ShiroKit.md5(newPwd, user.getSalt());
|
user.setPassword(newMd5);
|
user.updateById();
|
return R.ok();
|
} else {
|
// throw new GunsException(BizExceptionEnum.OLD_PWD_NOT_RIGHT);
|
return R.fail("原密码不正确");
|
}
|
}
|
|
@PostMapping("/api/changeInfo")
|
@ApiOperation(value = "修改个人信息", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R changeInfo(@RequestBody User user,HttpServletRequest request) {
|
|
userService.updateById(user);
|
return R.ok();
|
|
}
|
|
@PostMapping("/api/datalist")
|
@ApiOperation(value = "检测记录", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R<PageInfo<TUserDateData>> datalist(HttpServletRequest request, Integer pageNum, Integer pageSize, Integer night, String date) {
|
Integer userId = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
|
PageHelper.startPage(pageNum,pageSize);
|
|
EntityWrapper<TUserDateData> tUserDateDataEntityWrapper = new EntityWrapper<>();
|
|
tUserDateDataEntityWrapper.eq("userId",userId).last("ORDER BY date desc,night desc");
|
if (night!=null){
|
tUserDateDataEntityWrapper.eq("night",night).eq("date",date);
|
}
|
|
tUserDateDataEntityWrapper.setSqlSelect("id","date","night");
|
List<TUserDateData> tUserDateData = dateDataService.selectList(tUserDateDataEntityWrapper);
|
for (TUserDateData tUserDateDatum : tUserDateData) {
|
tUserDateDatum.setTUserDataArray(new TUserData[]{});
|
}
|
PageInfo<TUserDateData> info=new PageInfo<>(tUserDateData);
|
System.err.println(info);
|
|
return R.ok(info);
|
|
}
|
|
@PostMapping("/api/clear")
|
@ApiOperation(value = "设备clear", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R clear(String serNum) {
|
//获取当天18点的时间
|
redisService.setCacheObject("CLEAR:"+serNum, new Date());
|
|
return R.ok();
|
|
|
}
|
|
@PostMapping("/api/ifclear")
|
@ApiOperation(value = "设备是否需要clear", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R ifclear(String serNum) {
|
//获取当天18点的时间
|
Date cacheObject = redisService.getCacheObject("CLEAR:"+serNum);
|
|
if (cacheObject!=null){
|
Calendar calendar = Calendar.getInstance();
|
calendar.set(Calendar.HOUR_OF_DAY, 18);
|
calendar.set(Calendar.MINUTE, 0);
|
calendar.set(Calendar.SECOND, 0);
|
calendar.set(Calendar.MILLISECOND, 0);
|
|
Date dateAt1800 = calendar.getTime();
|
if (cacheObject.before(dateAt1800)){
|
return R.ok(false);
|
}else {
|
return R.ok(true);
|
}
|
}else {
|
return R.ok(true);
|
}
|
}
|
|
|
|
|
|
@PostMapping("/api/link")
|
@ApiOperation(value = "设备连接断开", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R link(@RequestBody LinkQuery linkQuery) {
|
TDevice serNum = deviceService.selectOne(new EntityWrapper<TDevice>().eq("serNum", linkQuery.getSerNum()));
|
serNum.setStatus(linkQuery.getStatus());
|
deviceService.updateById(serNum);
|
if (linkQuery.getStatus()==0){
|
Long timestamp = new Date().getTime();
|
redisService.setCacheObject(linkQuery.getSerNum(), timestamp.toString());
|
}
|
return R.ok();
|
|
|
}
|
|
@PostMapping("/api/last")
|
@ApiOperation(value = "获取上次断开时间", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R last(String serNum) {
|
String date = (String)redisService.getCacheObject(serNum);
|
return R.ok(date);
|
|
|
}
|
|
|
@PostMapping("/api/datadetail")
|
@ApiOperation(value = "检测记录详情", tags = {"App接口"}, notes = "")
|
@ResponseBody
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R<TUserDateData> datadetail(HttpServletRequest request,Integer dataId) {
|
TUserDateData tUserDateData = dateDataService.selectById(dataId);
|
|
|
ObjectMapper mapper = new ObjectMapper();
|
TUserData[] tUserDataArray = new TUserData[]{};
|
try {
|
// 将JSON字符串转换为TUserData数组
|
tUserDataArray = mapper.readValue(tUserDateData.getData(), TUserData[].class);
|
for (TUserData tUserData : tUserDataArray) {
|
tUserData.setTime(tUserData.getDetectionTime().getTime());
|
}
|
tUserDateData.setTUserDataArray(tUserDataArray);
|
// 打印转换后的数组，以便验证
|
System.out.println(Arrays.toString(tUserDataArray));
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
tUserDateData.setData(null);
|
|
return R.ok(tUserDateData);
|
|
}
|
|
@Autowired
|
private ITUserDataService userDataService;
|
|
@ResponseBody
|
@PostMapping("/api/pulldata")
|
@ApiOperation(value = "推送数据", tags = {"App接口"}, notes = "")
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "Authorization", value = "Bearer +token", required = true, dataType = "String", paramType = "header", defaultValue = "Bearer eyJhbGciOiJIUzUxMiJ9.....")
|
})
|
public R pulldata(HttpServletRequest request, @RequestParam("file") MultipartFile file) throws ParseException, JsonProcessingException {
|
Integer uid = redisService.getCacheObject(request.getHeader(JwtConstants.AUTH_HEADER));
|
List<TUserData> data = new ArrayList<>();
|
|
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
|
Workbook book = WoUtil.ImportFile(file);
|
Sheet sh = book.getSheetAt(0); //获取到第一个表
|
for (int i = 1; i <= sh.getLastRowNum(); i++) {
|
Row row = sh.getRow(i);
|
|
|
Cell cell2 = row.getCell(2); //所属加盟商[提示:加盟车辆选填]
|
Integer two = null;
|
if (SinataUtil.isNotEmpty(cell2)) {
|
two = (int)cell2.getNumericCellValue();
|
}
|
|
|
Cell cell4 = row.getCell(4); //服务模式:出租车[是/否]
|
String four = null;
|
if (SinataUtil.isNotEmpty(cell4)) {
|
four = String.valueOf(cell4.getStringCellValue()).trim();
|
}
|
|
Cell cell5 = row.getCell(1); // 服务模式: 出租车[是/否]
|
Date five = null;
|
int divisor = 5;
|
if (SinataUtil.isNotEmpty(cell5)) {
|
double numericValue = cell5.getNumericCellValue();
|
long timestamp = (long) numericValue; // 如果数值是整数毫秒时间戳
|
five = new Date(timestamp);
|
long seconds = timestamp / 1000;
|
|
// 判断秒数是否为divisor的倍数
|
boolean isMultiple = seconds % divisor == 0;
|
if (!isMultiple){
|
// continue;
|
}
|
} else {
|
// 处理单元格为空的情况
|
}
|
// System.err.println("====");
|
TUserData tUserData = new TUserData();
|
tUserData.setUserId(uid);
|
tUserData.setDetectionTime(five);
|
tUserData.setPosition(four);
|
tUserData.setShapeVariable(Integer.valueOf(two));
|
data.add(tUserData);
|
}
|
|
|
|
|
// data = userDataService.selectList(null);
|
Map<String, List<TUserData>> groupedData = data.stream()
|
.collect(Collectors.groupingBy(
|
item -> {
|
LocalDateTime dateTime = item.getDetectionTime().toInstant()
|
.atZone(ZoneId.systemDefault())
|
.toLocalDateTime();
|
LocalTime timeOfDay = dateTime.toLocalTime();
|
|
String groupKey;
|
if (timeOfDay.isAfter(LocalTime.of(22, 0))) {
|
// 晚上时间，归入前一天
|
LocalDate previousDay = dateTime.toLocalDate();
|
groupKey = previousDay + " 晚上";
|
} else if (timeOfDay.isBefore(LocalTime.of(10, 0))) {
|
LocalDate previousDay = dateTime.toLocalDate().minusDays(1);
|
|
// 早上的时间，即00:00 - 10:00
|
groupKey = previousDay + " 晚上";
|
} else {
|
// 其余时间，即10:00 - 22:00
|
groupKey = dateTime.toLocalDate() + " 白天";
|
}
|
return groupKey;
|
}
|
));
|
|
// 输出分组结果
|
for (Map.Entry<String, List<TUserData>> entry : groupedData.entrySet()) {
|
System.out.println("Group: " + entry.getKey());
|
String[] s = entry.getKey().split(" ");
|
System.out.println("Data: " + entry.getValue());
|
//判断是否已经存过数据，如果存过就在后面累加
|
List<TUserDateData> tUserDateData = dateDataService.selectList(new EntityWrapper<TUserDateData>().eq("userId", uid).eq("date", s[0]).eq("night", "晚上".equals(s[1]) ? 1 : 0));
|
//没有就直接save
|
if (!tUserDateData.isEmpty()){
|
//累加数据
|
TUserDateData tUserDateData1 = tUserDateData.get(0);
|
ObjectMapper mapper = new ObjectMapper();
|
TUserData[] tUserDataArray = new TUserData[]{};
|
try {
|
tUserDataArray = mapper.readValue(tUserDateData1.getData(), TUserData[].class);
|
System.out.println(Arrays.toString(tUserDataArray));
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
List<TUserData> list = new ArrayList<>(); // 初始化一个空的 ArrayList
|
list.addAll(Arrays.asList(tUserDataArray)); // 将原始数组添加到列表中
|
List<TUserData> value = entry.getValue();
|
list.addAll(value);
|
String jsonInString = mapper.writeValueAsString(list);
|
tUserDateData1.setData(jsonInString);
|
dateDataService.updateById(tUserDateData1);
|
}else {
|
TUserDateData tUserDateData2 = new TUserDateData();
|
ObjectMapper mapper = new ObjectMapper();
|
try {
|
// 将TUserData数组转换为JSON字符串
|
String jsonInString = mapper.writeValueAsString(entry.getValue());
|
System.out.println(jsonInString);
|
tUserDateData2.setData(jsonInString);
|
tUserDateData2.setNight("晚上".equals(s[1]) ? 1 : 0);
|
tUserDateData2.setUserId(uid);
|
tUserDateData2.setDate(s[0]);
|
dateDataService.insert(tUserDateData2);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
|
|
return R.ok();
|
|
|
}
|
|
|
|
@Autowired
|
private ITUserDateDataService dateDataService;
|
@ResponseBody
|
@PostMapping("/base/putdata")
|
@ApiOperation(value = "测试用接口", tags = {"App接口"}, notes = "")
|
public R<TDevice> putdata(HttpServletRequest request){
|
// 创建一个Random对象用于生成随机数
|
Random random = new Random();
|
|
// 计算总秒数，现在每隔10秒生成一条数据
|
int totalSeconds = 24 * 60 * 6; // 一天内每10秒一条数据
|
|
// 创建一个TUserData对象数组
|
TUserData[] tUserDataArray = new TUserData[totalSeconds];
|
|
// 生成并添加数据到数组中
|
Calendar calendar = Calendar.getInstance();
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
int shapeVariable = 0; // 初始化shapeVariable
|
for (int i = 0; i < totalSeconds; i++) {
|
// 设置检测时间为当前时间加上i*10秒
|
calendar.setTime(new Date());
|
calendar.add(Calendar.SECOND, i * 10);
|
Date detectionTime = calendar.getTime();
|
|
// 每10条数据shapeVariable才变化一次
|
if (i % 10 == 0) {
|
shapeVariable = random.nextInt(200) + 1; // 生成1到200之间的随机整数
|
}
|
|
// 假设userId也是1到100之间的随机整数
|
Integer userId = random.nextInt(100) + 1;
|
|
TUserData dataPoint = new TUserData();
|
dataPoint.setDetectionTime(detectionTime);
|
dataPoint.setShapeVariable(shapeVariable);
|
|
tUserDataArray[i] = dataPoint;
|
|
}
|
|
// 打印前10个数据点的时间戳和shapeVariable以验证
|
for (int i = 0; i < 10; i++) {
|
System.out.println("Detection Time: " + sdf.format(tUserDataArray[i].getDetectionTime()));
|
System.out.println("Shape Variable: " + tUserDataArray[i].getShapeVariable());
|
System.out.println("-------------");
|
}
|
String str = Arrays.stream(tUserDataArray)
|
.map(TUserData::toString)
|
.collect(Collectors.joining(", ", "[", "]"));
|
TUserDateData tUserDateData = new TUserDateData();
|
tUserDateData.setDate("2024-07-15");
|
tUserDateData.setUserId(1);
|
|
ObjectMapper mapper = new ObjectMapper();
|
try {
|
// 将TUserData数组转换为JSON字符串
|
String jsonInString = mapper.writeValueAsString(tUserDataArray);
|
System.out.println(jsonInString);
|
tUserDateData.setData(jsonInString);
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
|
dateDataService.insert(tUserDateData);
|
|
return R.ok();
|
}
|
|
|
|
}
|
