sourcecode/server/gateway-api/src/main/java/com/qxgmat/controller/admin/UserController.java

package com.qxgmat.controller.admin;

import com.github.pagehelper.Page;
import com.nuliji.tools.*;
import com.nuliji.tools.exception.ParameterException;
import com.qxgmat.data.constants.enums.ServiceKey;
import com.qxgmat.data.constants.enums.module.FeedbackModule;
import com.qxgmat.data.constants.enums.module.ProductType;
import com.qxgmat.data.constants.enums.status.DirectionStatus;
import com.qxgmat.data.constants.enums.status.FeedbackStatus;
import com.qxgmat.data.constants.enums.trade.PayMethod;
import com.qxgmat.data.constants.enums.trade.RecordSource;
import com.qxgmat.data.constants.enums.user.MoneyRange;
import com.qxgmat.data.dao.entity.*;
import com.qxgmat.dto.admin.extend.*;
import com.qxgmat.dto.admin.request.*;
import com.qxgmat.dto.admin.response.*;
import com.qxgmat.help.ShiroHelp;
import com.qxgmat.service.ManagerService;
import com.qxgmat.service.UserPaperService;
import com.qxgmat.service.UserServiceService;
import com.qxgmat.service.extend.*;
import com.qxgmat.service.UsersService;
import com.qxgmat.service.inline.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.*;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@RestController("AdminUserController")
@RequestMapping("/admin/user")
@Api(tags = "用户接口", description = "用户相关操作", produces = MediaType.APPLICATION_JSON_VALUE)
public class UserController {
    private static final Logger logger = LoggerFactory.getLogger(UserController.class);
    @Autowired
    private ShiroHelp shiroHelp;

    @Autowired
    private ManagerLogService managerLogService;

    @Autowired
    private CourseService courseService;

    @Autowired
    private CourseNoService courseNoService;

    @Autowired
    private CourseDataService courseDataService;

    @Autowired
    private CoursePackageService coursePackageService;

    @Autowired
    private QuestionService questionService;

    @Autowired
    private QuestionNoService questionNoService;

    @Autowired
    private UsersService usersService;

    @Autowired
    private UserServiceService userServiceService;

    @Autowired
    private UserCourseService userCourseService;

    @Autowired
    private UserPaperService userPaperService;

    @Autowired
    private UserReportService userReportService;

    @Autowired
    private UserOrderService userOrderService;

    @Autowired
    private ManagerService managerService;

    @Autowired
    private PreviewService previewService;

    @Autowired
    private PreviewPaperService previewPaperService;

    @Autowired
    private PreviewAssignService previewAssignService;

    @Autowired
    private TextbookLibraryService textbookLibraryService;

    @Autowired
    private TextbookTopicService textbookTopicService;

    @Autowired
    private UserCourseAppointmentService userCourseAppointmentService;

    @Autowired
    private UserCourseAppointmentCommentService userCourseAppointmentCommentService;

    @Autowired
    private UserFeedbackErrorService userFeedbackErrorService;

    @Autowired
    private UserTextbookFeedbackService userTextbookFeedbackService;

    @Autowired
    private UserOrderRecordService userOrderRecordService;

    @Autowired
    private UserOrderCheckoutService userOrderCheckoutService;

    @Autowired
    private QuestionFlowService questionFlowService;

    @Autowired
    private OrderFlowService orderFlowService;

    @Autowired
    private CourseExtendService courseExtendService;

    @Autowired
    private SentenceService sentenceService;

    @Autowired
    private UserInvoiceService userInvoiceService;

    @Autowired
    private UserAbnormalService userAbnormalService;

    @Autowired
    private UserCourseProgressService userCourseProgressService;

    @Autowired
    private UserCourseRecordService userCourseRecordService;

    @Autowired
    private MessageExtendService messageExtendService;

    @RequestMapping(value = "/token", method = RequestMethod.GET)
    @ApiOperation(value = "获取用户token", httpMethod = "GET")
    public Response<String> token(@RequestParam int id, HttpSession session) {
        User entity = usersService.get(id);
        String token = usersService.getTokenByUser(entity);

        return ResponseHelp.success(token);
    }

    @RequestMapping(value = "/add", method = RequestMethod.POST)
    @ApiOperation(value = "人工添加用户", httpMethod = "POST")
    public Response<Boolean> add(@RequestBody @Validated UserDto dto, HttpSession session) {
        User entity = Transform.dtoToEntity(dto);
        User in = usersService.getByMobile(entity.getArea(), entity.getMobile());
        if (in != null){
            throw new ParameterException("手机号已注册");
        }
        usersService.add(entity);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/detail", method = RequestMethod.GET)
    @ApiOperation(value = "获取用户", httpMethod = "GET")
    public Response<UserDetailDto> detail(@RequestParam int id, HttpSession session) {
        User entity = usersService.get(id);
        UserDetailDto dto = Transform.convert(entity, UserDetailDto.class);
        Integer time = 0;

        time += courseExtendService.studyTime(id, null, null);
        time += sentenceService.studyTime(id, null, null);
        time += questionFlowService.studyTime(id, null, null);
        dto.setTotalTime(time);

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/real", method = RequestMethod.POST)
    @ApiOperation(value = "实名认证", httpMethod = "POST")
    public Response<Boolean> real(@RequestBody @Validated UserRealDto dto, HttpSession session) {
        User in = usersService.get(dto.getId());
        if (in == null){
            throw new ParameterException("用户不存在");
        }
        if (in.getRealTime() != null){
            throw new ParameterException("实名认证已通过");
        }
        User entity = Transform.dtoToEntity(dto);
        entity.setRealStatus(1);
        entity.setRealTime(new Date());
        usersService.edit(entity);

        orderFlowService.giveReal(in.getId());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/money/add", method = RequestMethod.POST)
    @ApiOperation(value = "增加用户累计金额", httpMethod = "POST")
    public Response<Boolean> addMoney(@RequestBody @Validated UserMoneyDto dto, HttpSession session) {
        User in = usersService.get(dto.getId());
        if (in == null){
            throw new ParameterException("用户不存在");
        }
        usersService.accumulation(dto.getId(), BigDecimal.valueOf(dto.getMoney()));
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/frozen", method = RequestMethod.POST)
    @ApiOperation(value = "冻结用户", httpMethod = "POST")
    public Response<Boolean> frozen(@RequestBody @Validated UserFrozenDto dto, HttpSession session) {
        User entity = usersService.get(dto.getId());
        if (entity.getIsFrozen() > 0){
            throw new ParameterException("用户已冻结");
        }
        usersService.edit(User.builder()
                .id(dto.getId())
                .isFrozen(1)
                .build());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/nofrozen", method = RequestMethod.POST)
    @ApiOperation(value = "取消冻结用户", httpMethod = "POST")
    public Response<Boolean> noFrozen(@RequestBody @Validated UserFrozenDto dto, HttpSession session) {
        User entity = usersService.get(dto.getId());
        if (entity.getIsFrozen() == 0){
            throw new ParameterException("用户未冻结");
        }
        usersService.edit(User.builder()
                .id(dto.getId())
                .isFrozen(0)
                .build());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/list", method = RequestMethod.GET)
    @ApiOperation(value = "用户列表", httpMethod = "GET")
    public Response<PageMessage<UserListDto>> list(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false, defaultValue = "") String keyword,
            @RequestParam(required = false) Integer[] ids,
            @RequestParam(required = false) Boolean real,
            @RequestParam(required = false) Boolean wechat,
            @RequestParam(required = false) Boolean prepare,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<User> p;
        if (ids != null && ids.length > 0){
            p = usersService.select(ids);
        }else{
            p = usersService.listAdmin(page, size, keyword, real, wechat, prepare, startTime, endTime, order, DirectionStatus.ValueOf(direction));
        }
        List<UserListDto> pr = Transform.convert(p, UserListDto.class);

        Collection userIds = Transform.getIds(p, User.class, "id");
        // 绑定用户服务
        Map<Object, Collection<UserService>> serviceByUser = userServiceService.mapByUser(userIds);
        Transform.combine(pr, serviceByUser, UserListDto.class, "id", "services", UserServiceExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/student/list", method = RequestMethod.GET)
    @ApiOperation(value = "会员列表", httpMethod = "GET")
    public Response<PageMessage<UserListDto>> members(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false, defaultValue = "") String keyword,
            @RequestParam(required = false) Integer courseId,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        // 已经购买过课程的用户
        Page<User> p = usersService.listAdminByCourse(page, size, keyword, courseId, order, DirectionStatus.ValueOf(direction));
        List<UserListDto> pr = Transform.convert(p, UserListDto.class);

        Collection userIds = Transform.getIds(p, User.class, "id");

        // 绑定用户课程
        Map<Object, Collection<UserCourse>> courseByUser = userCourseService.mapByUser(userIds, false);
        Transform.combine(pr, courseByUser, UserListDto.class, "id", "classes", UserCourseExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/order/detail", method = RequestMethod.GET)
    @ApiOperation(value = "用户订单列表", httpMethod = "GET")
    public Response<UserOrderDetailDto> getOrder(@RequestParam int id,
            HttpSession session) {
        UserOrder entity = userOrderService.get(id);
        UserOrderDetailDto dto = Transform.convert(entity, UserOrderDetailDto.class);

        List<UserOrderRecordExtendDto> list;
        if(entity.getPayStatus() == 0){
            List<UserOrderCheckout> checkoutList = userOrderCheckoutService.allByUser(entity.getUserId(), entity.getId());
            list = Transform.convert(checkoutList, UserOrderRecordExtendDto.class);
        }else{
            List<UserOrderRecord> recordList = userOrderRecordService.allByUser(entity.getUserId(), entity.getId());
            list = Transform.convert(recordList, UserOrderRecordExtendDto.class);
        }
        dto.setCheckouts(list);

        List<UserOrderRecordExtendDto> courseCheckout = list.stream().filter((row)->row.getProductType().equals(ProductType.COURSE.key)).collect(Collectors.toList());
        Collection courseIds = Transform.getIds(courseCheckout, UserOrderRecordExtendDto.class, "productId");
        List<Course> courseList = courseService.select(courseIds);
        dto.setCourses(Transform.convert(courseList, CourseExtendDto.class));

        List<UserOrderRecordExtendDto> dataCheckout = list.stream().filter((row)->row.getProductType().equals(ProductType.DATA.key)).collect(Collectors.toList());
        Collection dataIds = Transform.getIds(dataCheckout, UserOrderRecordExtendDto.class, "productId");
        List<CourseData> dataList = courseDataService.select(dataIds);
        dto.setDatas(Transform.convert(dataList, CourseDataExtendDto.class));

        List<UserOrderRecordExtendDto> packageCheckout = list.stream().filter((row)->row.getProductType().equals(ProductType.COURSE_PACKAGE.key)).collect(Collectors.toList());
        Collection packageIds = Transform.getIds(packageCheckout, UserOrderRecordExtendDto.class, "productId");
        List<CoursePackage> packageList = coursePackageService.select(packageIds);
        dto.setPackages(Transform.convert(packageList, CoursePackageExtendDto.class));

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/order/finish", method = RequestMethod.PUT)
    @ApiOperation(value = "完成支付", httpMethod = "PUT")
    private Response<Boolean> finishOrder(@RequestBody @Validated UserOrderFinishDto dto){
        UserOrder order = userOrderService.get(dto.getId());
        orderFlowService.payed(order.getId(), order.getUserId(), 0L, new Date(), PayMethod.BANK, dto.getTransactionNo());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/order/list", method = RequestMethod.GET)
    @ApiOperation(value = "用户订单列表", httpMethod = "GET")
    public Response<PageMessage<UserOrderListDto>> listOrder(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) String productType,
            @RequestParam(required = false) String payMethod,
            @RequestParam(required = false) Integer orderId,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserOrder> p = userOrderService.listAdmin(page, size, userId, productType, payMethod, orderId, order, DirectionStatus.ValueOf(direction));
        List<UserOrderListDto> pr = Transform.convert(p, UserOrderListDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserOrder.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserOrderListDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/record/stop", method = RequestMethod.PUT)
    @ApiOperation(value = "停止记录", httpMethod = "PUT")
    private Response<Boolean> editService(@RequestBody @Validated UserRecordStopDto dto){
        orderFlowService.stopRecord(dto.getId());
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/record/list", method = RequestMethod.GET)
    @ApiOperation(value = "用户购买列表", httpMethod = "GET")
    public Response<PageMessage<UserOrderRecordListDto>> listRecord(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer orderId,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) String productType,
            @RequestParam(required = false) Integer productId,
            @RequestParam(required = false) String service,
            @RequestParam(required = false) Boolean needMoney,
            @RequestParam(required = false) Boolean needPackage,
            @RequestParam(required = false) String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserOrderRecord> p = userOrderRecordService.listAdmin(page, size, orderId, userId, ProductType.ValueOf(productType), productId, ServiceKey.ValueOf(service), needMoney,needPackage, order, DirectionStatus.ValueOf(direction));
        List<UserOrderRecordListDto> pr = Transform.convert(p, UserOrderRecordListDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserOrderRecord.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserOrderRecordListDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        // 绑定课程
        List<UserOrderRecordListDto> prCourse = pr.stream().filter((row)-> row.getProductType().equals(ProductType.COURSE.key)).collect(Collectors.toList());
        Collection courseIds = Transform.getIds(prCourse, UserOrderRecordListDto.class, "productId");
        List<Course> courseList = courseService.select(courseIds);
        Transform.combine(prCourse, courseList, UserOrderRecordListDto.class, "productId", "course", Course.class, "id", CourseExtendDto.class);

        // 绑定资料
        List<UserOrderRecordListDto> prData = pr.stream().filter((row)-> row.getProductType().equals(ProductType.DATA.key)).collect(Collectors.toList());
        Collection dataIds = Transform.getIds(prData, UserOrderRecordListDto.class, "productId");
        List<CourseData> dataList = courseDataService.select(dataIds);
        Transform.combine(prData, dataList, UserOrderRecordListDto.class, "productId", "data", CourseData.class, "id", CourseDataExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/data/add", method = RequestMethod.POST)
    @ApiOperation(value = "添加资料记录", httpMethod = "POST")
    private Response<Boolean> addData(@RequestBody @Validated UserDataRecordDto dto){
        UserOrderRecord entity = Transform.dtoToEntity(dto);
        entity.setProductType(ProductType.DATA.key);
        entity.setOrderId(0);
        entity.setProductId(dto.getDataId());
        if (dto.getMobile() != null && !dto.getMobile().isEmpty()){
            // 判断mobile
            User user = usersService.getByMobile(dto.getArea(), dto.getMobile());
            if (user == null){
                // 创建user
                user = usersService.register(dto.getArea(), dto.getMobile(), null,null, null,"", null);
            }
            entity.setUserId(user.getId());
        }
        // 后台服务创建，都默认你为后台创建
        entity.setSource(RecordSource.BACKEND.key);
        orderFlowService.addRecord(entity);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/service/add", method = RequestMethod.POST)
    @ApiOperation(value = "添加服务记录", httpMethod = "POST")
    private Response<Boolean> addService(@RequestBody @Validated UserServiceRecordDto dto){
        UserOrderRecord entity = Transform.dtoToEntity(dto);
        entity.setProductType(ProductType.SERVICE.key);
        entity.setOrderId(0);
        entity.setProductId(0);
        if (dto.getMobile() != null && !dto.getMobile().isEmpty()){
            // 判断mobile
            User user = usersService.getByMobile(dto.getArea(), dto.getMobile());
            if (user == null){
                // 创建user
                user = usersService.register(dto.getArea(), dto.getMobile(), null,null, null,"", null);
            }
            entity.setUserId(user.getId());
        }
        // 后台服务创建，都默认你为后台创建
        entity.setSource(RecordSource.BACKEND.key);
        orderFlowService.addRecord(entity);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/service/list", method = RequestMethod.GET)
    @ApiOperation(value = "获取服务列表", httpMethod = "GET")
    private Response<PageMessage<UserServiceRecordInfoDto>> listService(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String service,
            @RequestParam(required = false) String param,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction
    ){
        Page<UserOrderRecord> p = userOrderRecordService.listWithServiceAdmin(page, size, ServiceKey.ValueOf(service), param, userId);
        List<UserServiceRecordInfoDto> pr = Transform.convert(p, UserServiceRecordInfoDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserOrderRecord.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserServiceRecordInfoDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/feedback_error/edit", method = RequestMethod.PUT)
    @ApiOperation(value = "修改勘误信息", httpMethod = "PUT")
    public Response<Boolean> editFeedbackError(@RequestBody @Validated UserFeedbackErrorDto dto, HttpServletRequest request) {
        UserFeedbackError entity = Transform.dtoToEntity(dto);
        UserFeedbackError in = userFeedbackErrorService.get(entity.getId());

        // 处理设定
        if(in.getHandleTime() == null){
            entity.setHandleTime(new Date());
            Manager manager = shiroHelp.getLoginManager();
            entity.setManagerId(manager.getId());
            User user = usersService.get(in.getUserId());
            messageExtendService.sendFeedbackAnswer(user, in);
        }

        entity = userFeedbackErrorService.edit(entity);

        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/feedback_error/detail", method = RequestMethod.GET)
    @ApiOperation(value = "勘误详情", httpMethod = "GET")
    public Response<UserFeedbackErrorInfoDto> detailFeedbackError(@RequestParam int id, HttpServletRequest request) {
        UserFeedbackError entity = userFeedbackErrorService.get(id);
        UserFeedbackErrorInfoDto dto = Transform.convert(entity, UserFeedbackErrorInfoDto.class);
        User user = usersService.get(entity.getUserId());
        UserExtendDto userDto = Transform.convert(user, UserExtendDto.class);
        dto.setUser(userDto);

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/feedback_error/list", method = RequestMethod.GET)
    @ApiOperation(value = "勘误列表", httpMethod = "GET")
    public Response<PageMessage<UserFeedbackErrorInfoDto>> listFeedbackError(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String module,
            @RequestParam(required = false) String questionType,
            @RequestParam(required = false) String target,
            @RequestParam(required = false) Integer moduleId,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer status,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) Integer moneyRang,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserFeedbackError> p = userFeedbackErrorService.listAdmin(page, size, FeedbackModule.ValueOf(module), FeedbackStatus.ValueOf(status), questionType, target, moduleId, keyword, userId, MoneyRange.ValueOf(moneyRang), order, DirectionStatus.ValueOf(direction));
        List<UserFeedbackErrorInfoDto> pr = Transform.convert(p, UserFeedbackErrorInfoDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserFeedbackError.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserFeedbackErrorInfoDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/textbook_feedback/edit", method = RequestMethod.PUT)
    @ApiOperation(value = "修改机经勘误信息", httpMethod = "PUT")
    public Response<Boolean> editTextbookFeedback(@RequestBody @Validated UserFeedbackErrorDto dto, HttpServletRequest request) {
        UserFeedbackError entity = Transform.dtoToEntity(dto);
        UserFeedbackError in = userFeedbackErrorService.get(entity.getId());

        // 处理设定
        if(in.getHandleTime() == null){
            entity.setHandleTime(new Date());
            Manager manager = shiroHelp.getLoginManager();
            entity.setManagerId(manager.getId());
        }

        entity = userFeedbackErrorService.edit(entity);

        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/textbook_feedback/detail", method = RequestMethod.GET)
    @ApiOperation(value = "机经勘误详情", httpMethod = "GET")
    public Response<UserTextbookFeedbackInfoDto> detailTextbookFeedback(@RequestParam int id, HttpServletRequest request) {
        UserTextbookFeedback entity = userTextbookFeedbackService.get(id);
        UserTextbookFeedbackInfoDto dto = Transform.convert(entity, UserTextbookFeedbackInfoDto.class);

        User user = usersService.get(entity.getUserId());
        UserExtendDto userDto = Transform.convert(user, UserExtendDto.class);
        dto.setUser(userDto);

        TextbookLibrary library = textbookLibraryService.get(entity.getLibraryId());
        TextbookLibraryExtendDto libraryDto = Transform.convert(library, TextbookLibraryExtendDto.class);
        dto.setLibrary(libraryDto);

        TextbookTopic topic = textbookTopicService.get(entity.getTopicId());
        TextbookTopicExtendDto topicDto = Transform.convert(library, TextbookTopicExtendDto.class);
        dto.setTopic(topicDto);

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/textbook_feedback/list", method = RequestMethod.GET)
    @ApiOperation(value = "机经勘误列表", httpMethod = "GET")
    public Response<PageMessage<UserTextbookFeedbackInfoDto>> listTextbookFeedback(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) String target,
            @RequestParam(required = false) String questionSubject,
            @RequestParam(required = false) Integer status,
            @RequestParam(required = false) Integer no,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserTextbookFeedback> p = userTextbookFeedbackService.listAdmin(page, size, target, questionSubject, FeedbackStatus.ValueOf(status), no, order, DirectionStatus.ValueOf(direction));
        List<UserTextbookFeedbackInfoDto> pr = Transform.convert(p, UserTextbookFeedbackInfoDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserTextbookFeedback.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserTextbookFeedbackInfoDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        // 绑定换库
        Collection libraryIds = Transform.getIds(p, UserTextbookFeedback.class, "libraryId");
        List<TextbookLibrary> libraryList = textbookLibraryService.select(libraryIds);
        Transform.combine(pr, libraryList,  UserTextbookFeedbackInfoDto.class, "libraryId", "library", TextbookLibrary.class, "id", TextbookLibraryExtendDto.class);

        // 绑定题目
        Collection topicIds = Transform.getIds(p, UserTextbookFeedback.class, "topicId");
        List<TextbookTopic> topicList = textbookTopicService.select(topicIds);
        Transform.combine(pr, topicList,  UserTextbookFeedbackInfoDto.class, "topicId", "topic", TextbookTopic.class, "id", TextbookTopicExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/course/appointment/add", method = RequestMethod.POST)
    @ApiOperation(value = "添加课程预约", httpMethod = "POST")
    public Response<UserCourseAppointment> addCourseAppointment(@RequestBody @Validated UserCourseAppointmentDto dto, HttpServletRequest request) {
        // 判断课程是否已开通，否则先开通课程
        UserOrderRecord record = userOrderRecordService.get(dto.getRecordId());
        if (record==null){
            throw new ParameterException("记录不存在");
        }
        if (record.getIsUsed()==0){
            orderFlowService.useRecord(dto.getUserId(), dto.getRecordId());
        }else if(record.getIsStop() > 0){
            throw new ParameterException("已停用");
        }
        UserCourseAppointment entity = Transform.dtoToEntity(dto);
        entity = userCourseAppointmentService.addAppointment(entity);
        // 第一次预约，开通
        if (entity.getNo() == 1){
            orderFlowService.useRecord(record.getUserId(), record.getId());
        }
        managerLogService.log(request);
        return ResponseHelp.success(Transform.convert(entity, CourseTime.class));
    }

    @RequestMapping(value = "/course/appointment/edit", method = RequestMethod.PUT)
    @ApiOperation(value = "编辑课程预约", httpMethod = "PUT")
    public Response<Boolean> editCourseAppointment(@RequestBody @Validated UserCourseAppointmentDto dto, HttpServletRequest request) {
        UserCourseAppointment entity = Transform.dtoToEntity(dto);
        entity = userCourseAppointmentService.edit(entity);
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/appointment/delete", method = RequestMethod.DELETE)
    @ApiOperation(value = "删除课程预约", httpMethod = "DELETE")
    public Response<Boolean> deleteCourseAppointment(@RequestParam int id, HttpServletRequest request) {
        UserCourseAppointment in = userCourseAppointmentService.get(id);
        // 调整课时序号
        userCourseAppointmentService.deleteAppointment(id);
        // 删除对应预习作业关系
        previewAssignService.removeCourseAppointment(in.getCourseId(), in.getId());
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/appointment/detail", method = RequestMethod.GET)
    @ApiOperation(value = "获取课程预约", httpMethod = "GET")
    public Response<CourseTime> detailCourseAppointment(@RequestParam int id,HttpSession session) {
        UserCourseAppointment entity = userCourseAppointmentService.get(id);
        return ResponseHelp.success(Transform.convert(entity, UserCourseAppointment.class));
    }

    @RequestMapping(value = "/course/appointment/list", method = RequestMethod.GET)
    @ApiOperation(value = "课程预约列表", httpMethod = "GET")
    public Response<PageMessage<UserCourseAppointmentInfoDto>> listCourseAppointment(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer[] ids,
            @RequestParam(required = false) Integer recordId,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer courseId,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {

        Page<UserCourseAppointment> p;
        if (ids != null && ids.length > 0){
            p = userCourseAppointmentService.select(ids);
        }else{
            p = userCourseAppointmentService.listAdmin(page, size, recordId, userId, courseId, startTime, endTime, order, DirectionStatus.ValueOf(direction));
        }
        List<UserCourseAppointmentInfoDto> pr = Transform.convert(p, UserCourseAppointmentInfoDto.class);

        // 绑定作业记录
        Collection appointmentIds = Transform.getIds(p, UserCourseAppointment.class, "id");
        List<PreviewAssign> previewAssignList = previewAssignService.listWithAppointment(appointmentIds);
        Map previewAssignMap = Transform.getMap(previewAssignList, PreviewAssign.class, "courseAppointment", "id");
        Collection assignIds = Transform.getIds(previewAssignList, PreviewAssign.class, "id");
        List<UserPaper> userPaperList=userPaperService.listWithAppointment(assignIds);
        Map userPaperMap = Transform.getMap(userPaperList, UserPaper.class, "originId", "id");
        for(UserCourseAppointmentInfoDto dto : pr){
            dto.setPaperId((Integer)userPaperMap.get(previewAssignMap.get(dto.getId())));
        }
        Transform.combine(pr, userPaperList, UserCourseAppointmentInfoDto.class, "paperId", "userPaper", UserPaper.class, "id", UserPaperExtendDto.class);

        // 获取最后一次作业结果
        Collection paperIds = Transform.getIds(userPaperList, UserPaper.class, "id");
        List<UserReport> reportList = userReportService.listWithLast(paperIds);
        Transform.combine(pr, reportList, UserCourseAppointmentInfoDto.class, "paperId", "userReport", UserReport.class, "paperId", UserReportExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/course/appointment/comment/add", method = RequestMethod.POST)
    @ApiOperation(value = "添加课程预约评论", httpMethod = "POST")
    public Response<UserCourseAppointment> addCourseAppointmentComment(@RequestBody @Validated UserCourseAppointmentCommentDto dto, HttpServletRequest request) {
        UserCourseAppointmentComment entity = Transform.dtoToEntity(dto);
        if (entity.getParentId() > 0){
            UserCourseAppointmentComment comment = userCourseAppointmentCommentService.get(entity.getParentId());
            if (comment != null){
                entity.setReply(comment.getContent());
            }
        }
        entity = userCourseAppointmentCommentService.add(entity);
        managerLogService.log(request);
        return ResponseHelp.success(Transform.convert(entity, CourseTime.class));
    }

    @RequestMapping(value = "/course/appointment/comment/edit", method = RequestMethod.PUT)
    @ApiOperation(value = "编辑课程预约聊天", httpMethod = "PUT")
    public Response<Boolean> editCourseAppointmentComment(@RequestBody @Validated UserCourseAppointmentCommentDto dto, HttpServletRequest request) {
        UserCourseAppointmentComment entity = Transform.dtoToEntity(dto);
        if (entity.getParentId() > 0){
            UserCourseAppointmentComment comment = userCourseAppointmentCommentService.get(entity.getParentId());
            if (comment != null){
                entity.setReply(comment.getContent());
            }
        }
        entity = userCourseAppointmentCommentService.edit(entity);
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/appointment/comment/delete", method = RequestMethod.DELETE)
    @ApiOperation(value = "删除课程预约聊天", httpMethod = "DELETE")
    public Response<Boolean> deleteCourseAppointmentComment(@RequestParam int id, HttpServletRequest request) {
        UserCourseAppointmentComment in = userCourseAppointmentCommentService.get(id);
        userCourseAppointmentCommentService.delete(id);
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/course/appointment/comment/all", method = RequestMethod.GET)
    @ApiOperation(value = "课程预约评论列表", httpMethod = "GET")
    public Response<List<UserCourseAppointmentComment>> listCourseAppointment(
            @RequestParam(required = false) Integer appointmentId,
            @RequestParam(required = false) String type,
            HttpSession session) {

        List<UserCourseAppointmentComment> p = userCourseAppointmentCommentService.allAdmin(appointmentId, type);

        return ResponseHelp.success(p);
    }

    @RequestMapping(value = "/course/record/all", method = RequestMethod.GET)
    @ApiOperation(value = "课程学习列表", httpMethod = "GET")
    public Response<List<UserCourseProgressInfoDto>> allCourseRecord(
            @RequestParam(required = false) Integer recordId,
            HttpSession session) {
        UserOrderRecord record = userOrderRecordService.get(recordId);
        Integer courseId = record.getProductId();
        Integer userId = record.getUserId();
        List<UserCourseProgress> p = userCourseProgressService.listCourse(recordId, courseId);

        List<UserCourseProgressInfoDto> pr = Transform.convert(p, UserCourseProgressInfoDto.class);

        // 绑定课时
        Collection courseNoIds = Transform.getIds(p, UserCourseProgress.class, "courseNoId");
        List<CourseNo> courseNoList = courseNoService.select(courseNoIds);
        Transform.combine(pr, courseNoList, UserCourseProgressInfoDto.class, "courseNoId", "courseNo", CourseNo.class, "id", CourseNoExtendDto.class);

        // 绑定所有学习记录
        Map<Integer, List<UserCourseRecord>> recordMap = userCourseRecordService.groupByCourse(recordId, courseNoIds);
        for(UserCourseProgressInfoDto dto : pr){
            dto.setRecords(recordMap.getOrDefault(dto.getCourseNoId(), null));
        }

        // 绑定预习作业
        List<PreviewAssign> previewAssignList = previewAssignService.listByCourseNos(courseId, courseNoIds);
        Map previewAssignMap = Transform.getMap(previewAssignList, PreviewAssign.class, "courseNo", "id");
        Collection assignIds = Transform.getIds(previewAssignList, PreviewAssign.class, "id");
        List<UserPaper> userPaperList = userPaperService.listWithCourse(userId, assignIds, recordId);
        Map userPaperMap = Transform.getMap(userPaperList, UserPaper.class, "originId", "id");
        for(UserCourseProgressInfoDto dto : pr){
            dto.setPaperId((Integer)userPaperMap.get(previewAssignMap.get(dto.getId())));
        }
        Transform.combine(pr, userPaperList, UserCourseProgressInfoDto.class, "paperId", "userPaper", UserPaper.class, "id", UserPaperExtendDto.class);

        // 获取最后一次作业结果
        Collection paperIds = Transform.getIds(userPaperList, UserPaper.class, "id");
        List<UserReport> reportList = userReportService.listWithLast(paperIds);
        Transform.combine(pr, reportList, UserCourseProgressInfoDto.class, "paperId", "userReport", UserReport.class, "paperId", UserReportExtendDto.class);

        return ResponseHelp.success(pr);
    }

    @RequestMapping(value = "/invoice/finish", method = RequestMethod.PUT)
    @ApiOperation(value = "开发票", httpMethod = "PUT")
    public Response<Boolean> finishInvoice(@RequestBody @Validated InvoiceFinishDto dto,
            HttpServletRequest request) {
        userInvoiceService.finish(dto.getIds());
        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/invoice/download", method = RequestMethod.GET)
    @ApiOperation(value = "下载发票", httpMethod = "GET")
    public Response<Boolean> downloadInvoice(
            @RequestParam(required = false) Integer[] ids,
            HttpServletRequest request, HttpServletResponse response) throws IOException {
        managerLogService.log(request);
        userInvoiceService.download(ids);
        List<UserInvoice> list = userInvoiceService.select(ids);
        Collection userIds = Transform.getIds(list, UserInvoice.class, "userId");
        List<User> userList = usersService.select(userIds);
        Map userMap = Transform.getMap(userList, User.class, "id");
        Collection orderIds = Transform.getIds(list, UserInvoice.class, "orderId");
        List<UserOrder> orderList = userOrderService.select(orderIds);
        Map orderMap = Transform.getMap(orderList, UserOrder.class, "id");

        String columnNames[]={"申请时间","用户昵称","用户ID","用户手机号","开票今金额","开票内容", "发票抬头", "纳税人识别号", "收件邮箱"};//列名
        String filename = "发票";
        //生成一个Excel文件
        // 创建excel工作簿
        Workbook wb = new HSSFWorkbook();
        // 创建第一个sheet（页），并命名
        Sheet sheet = wb.createSheet();
        // 创建第一行
        Row row = sheet.createRow(0);
        //设置列名
        for(int i=0;i<columnNames.length;i++){
            Cell cell = row.createCell(i);
            cell.setCellValue(columnNames[i]);
        }
        int i = 0;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        for(UserInvoice invoice : list){
            i+=1;
            int j = -1;
            Row r = sheet.createRow(i);
            User user = (User) userMap.get(invoice.getUserId());
            UserOrder userOrder = (UserOrder) orderMap.get(invoice.getOrderId());
            Cell time = r.createCell(++j);
            time.setCellValue(sdf.format(invoice.getCreateTime()));
            Cell nickname = r.createCell(++j);
            nickname.setCellValue(user.getNickname());
            Cell userId = r.createCell(++j);
            userId.setCellValue(user.getId());
            Cell mobile = r.createCell(++j);
            mobile.setCellValue(user.getMobile());
            Cell invoiceMoney = r.createCell(++j);
            invoiceMoney.setCellValue(userOrder.getInvoiceMoney().toString());
            Cell content = r.createCell(++j);
            content.setCellValue("服务费:");
            Cell title = r.createCell(++j);
            title.setCellValue(invoice.getTitle());
            Cell identity = r.createCell(++j);
            identity.setCellValue(invoice.getIdentity());
            Cell email = r.createCell(++j);
            email.setCellValue(user.getEmail());
        }
        //同理可以设置数据行
        ByteArrayOutputStream os = new ByteArrayOutputStream();
        try {
            wb.write(os);
        } catch (IOException e) {
            e.printStackTrace();
        }
        byte[] content = os.toByteArray();
        InputStream is = new ByteArrayInputStream(content);
        // 设置response参数，可以打开下载页面
        response.reset();
        response.setContentType("application/vnd.ms-excel;charset=utf-8");
        response.setHeader("Content-Disposition", "attachment;filename="+ new String((filename + ".xls").getBytes(), "iso-8859-1"));
        ServletOutputStream out = response.getOutputStream();
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            bis = new BufferedInputStream(is);
            bos = new BufferedOutputStream(out);
            byte[] buff = new byte[2048];
            int bytesRead;
            // Simple read/write loop.
            while (-1 != (bytesRead = bis.read(buff, 0, buff.length))) {
                bos.write(buff, 0, bytesRead);
            }
        } catch (final IOException e) {
            throw e;
        } finally {
            if (bis != null)
                bis.close();
            if (bos != null)
                bos.close();
        }
        return null;
    }

    @RequestMapping(value = "/invoice/list", method = RequestMethod.GET)
    @ApiOperation(value = "发票列表", httpMethod = "GET")
    public Response<PageMessage<UserInvoiceListDto>> listInvoice(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Boolean isFinish,
            @RequestParam(required = false) Boolean isDownload,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserInvoice> p = userInvoiceService.listAdmin(page, size, userId, isDownload, isFinish, order, DirectionStatus.ValueOf(direction));
        List<UserInvoiceListDto> pr = Transform.convert(p, UserInvoiceListDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserInvoice.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserInvoiceListDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        // 绑定订单
        Collection orderIds = Transform.getIds(p, UserInvoice.class, "orderId");
        List<UserOrder> orderList = userOrderService.select(orderIds);
        Transform.combine(pr, orderList, UserInvoiceListDto.class, "orderId", "order", UserOrder.class, "id", UserOrderExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }

    @RequestMapping(value = "/valid/mobile", method = RequestMethod.GET)
    @ApiOperation(value = "验证手机号", notes="查询手机对应账号", httpMethod = "GET")
    public Response<Boolean> validMobile(
            @RequestParam(required = true) String area,
            @RequestParam(required = true) String mobile
    ){
        User user = usersService.getByMobile(area, mobile);
        if(user != null){
            return ResponseHelp.success(false);
        }
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/abnormal/handler", method = RequestMethod.POST)
    @ApiOperation(value = "异常登录处理", httpMethod = "POST")
    public Response<Boolean> editAbnormal(@RequestBody @Validated UserAbnormalHandlerDto dto, HttpServletRequest request) {
        UserAbnormal entity = Transform.dtoToEntity(dto);
        UserAbnormal in = userAbnormalService.get(entity.getId());
        if (in.getIsAlert() != null && in.getIsAlert()  > 0){
            throw new ParameterException("已处理");
        }
        if (in.getIsIgnore() != null && in.getIsIgnore() > 0){
            throw new ParameterException("已处理");
        }

        if (dto.getIsAlert() != null && dto.getIsAlert() > 1){
            User user = usersService.get(in.getUserId());
            usersService.edit(User.builder().id(user.getId()).totalAlert(user.getTotalAlert() + 1).build());
            messageExtendService.sendLoginAbnormal(user, in);
        }

        entity = userAbnormalService.edit(entity);

        managerLogService.log(request);
        return ResponseHelp.success(true);
    }

    @RequestMapping(value = "/abnormal/detail", method = RequestMethod.GET)
    @ApiOperation(value = "异常登录详情", httpMethod = "GET")
    public Response<UserAbnormalInfoDto> detailAbnormal(@RequestParam int id, HttpServletRequest request) {
        UserAbnormal entity = userAbnormalService.get(id);
        UserAbnormalInfoDto dto = Transform.convert(entity, UserAbnormalInfoDto.class);
        User user = usersService.get(entity.getUserId());
        UserExtendDto userDto = Transform.convert(user, UserExtendDto.class);
        dto.setUser(userDto);

        return ResponseHelp.success(dto);
    }

    @RequestMapping(value = "/abnormal/list", method = RequestMethod.GET)
    @ApiOperation(value = "异常登录列表", httpMethod = "GET")
    public Response<PageMessage<UserAbnormalInfoDto>> listAbnormal(
            @RequestParam(required = false, defaultValue = "1") int page,
            @RequestParam(required = false, defaultValue = "100") int size,
            @RequestParam(required = false) Integer userId,
            @RequestParam(required = false) Integer totalAlert,
            @RequestParam(required = false) String startTime,
            @RequestParam(required = false) String endTime,
            @RequestParam(required = false, defaultValue = "id") String order,
            @RequestParam(required = false, defaultValue = "desc") String direction,
            HttpSession session) {
        Page<UserAbnormal> p = userAbnormalService.listAdmin(page, size, userId, totalAlert, startTime, endTime, order, DirectionStatus.ValueOf(direction));
        List<UserAbnormalInfoDto> pr = Transform.convert(p, UserAbnormalInfoDto.class);

        // 绑定用户
        Collection userIds = Transform.getIds(p, UserAbnormal.class, "userId");
        List<User> userList = usersService.select(userIds);
        Transform.combine(pr, userList, UserAbnormalInfoDto.class, "userId", "user", User.class, "id", UserExtendDto.class);

        return ResponseHelp.success(pr, page, size, p.getTotal());
    }
}