潘钊 / bsth_control · Files

package com.bsth.controller;


import com.bsth.common.ResponseCode;
import com.bsth.service.BaseService;
import com.bsth.service.schedule.utils.DataImportExportService;
import com.google.common.base.Splitter;
import jxl.Sheet;
import jxl.Workbook;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.util.CollectionUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Created by xu on 16/11/3.
 */
public class BaseController2<T, ID extends Serializable> {

    @Autowired
    protected BaseService<T, ID> baseService;
    @Autowired
    DataImportExportService dataImportExportService;

    /**
     *
     * @Title: list
     * @Description: TODO(多条件分页查询)
     * @param @param map 查询条件
     * @param @param page 页码
     * @param @param size 每页显示数量
     * @throws
     */
    @RequestMapping(method = RequestMethod.GET)
    public Page<T> list(@RequestParam Map<String, Object> map,
                        @RequestParam(defaultValue = "0") int page,
                        @RequestParam(defaultValue = "10") int size,
                        @RequestParam(defaultValue = "id") String order,
                        @RequestParam(defaultValue = "DESC") String direction){

        // 允许多个字段排序，order可以写单个字段，也可以写多个字段
        // 多个字段格式：{col1},{col2},{col3},....,{coln}
        List<String> order_columns = Splitter.on(",").trimResults().splitToList(order);
        // 多字段排序：DESC,ASC...
        List<String> order_dirs = Splitter.on(",").trimResults().splitToList(direction);

        if (order_dirs.size() == 1) { // 所有字段采用一种排序
            if (null != order_dirs.get(0) && order_dirs.get(0).equals("ASC")) {
                return baseService.list(map, new PageRequest(page, size, new Sort(Sort.Direction.ASC, order_columns)));
            } else {
                return baseService.list(map, new PageRequest(page, size, new Sort(Sort.Direction.DESC, order_columns)));
            }
        } else if (order_columns.size() == order_dirs.size()) {
            List<Sort.Order> orderList = new ArrayList<>();
            for (int i = 0; i < order_columns.size(); i++) {
                if (null != order_dirs.get(i) && order_dirs.get(i).equals("ASC")) {
                    orderList.add(new Sort.Order(Sort.Direction.ASC, order_columns.get(i)));
                } else {
                    orderList.add(new Sort.Order(Sort.Direction.DESC, order_columns.get(i)));
                }
            }
            return baseService.list(map, new PageRequest(page, size, new Sort(orderList)));
        } else {
            throw new RuntimeException("多字段排序参数格式问题，排序顺序和字段数不一致");
        }
    }

    /**
     *
     * @Title: list
     * @Description: TODO(多条件查询)
     * @param @param map
     * @throws
     */
    @RequestMapping(value = "/all", method = RequestMethod.GET)
    public Iterable<T> list(@RequestParam Map<String, Object> map){
        return baseService.list(map);
    }

    /**
     * 这里保存直接返回保存后的对象，不自己定义Map返回了，和前端angularjs配合。
     * form也可以提交，但是页面参数可能不全，
     * json的化比较灵活，但是貌似有多余属性也会报错，或者碰到lazy属性值，也有问题
     * 不论form，还是json提交都能解决问题，就看哪个方便哪个来
     *
     * @param t 参数需要使用@RequestBody转换json成对象
     * @return
     */
    @RequestMapping(method = RequestMethod.POST)
    public T save(@RequestBody T t) {
        baseService.save(t);
        return t;
    }

    @RequestMapping(value="/{id}", method = RequestMethod.POST)
    public T update(@RequestBody T t) {
        baseService.save(t);
        return t;
    }

    /**
     *
     * @Title: findById
     * @Description: TODO(根据主键获取单个对象)
     * @param @param id
     * @throws
     */
    @RequestMapping(value="/{id}",method = RequestMethod.GET)
    public T findById(@PathVariable("id") ID id){
        return baseService.findById(id);
    }

    /**
     *
     * @Title: delete
     * @Description: TODO(根据主键删除对象)
     * @param @param id
     * @throws
     */
    @RequestMapping(value="/{id}",method = RequestMethod.DELETE)
    public Map<String, Object> delete(@PathVariable("id") ID id){
        return baseService.delete(id);
    }

    /**
     * 上传数据文件，并使用ktr转换文件导入数据。
     * @param file
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/dataImport", method = RequestMethod.POST)
    public Map<String, Object> uploadDataAndImport(MultipartFile file) throws Exception {
        Map<String, Object> resultMap = new HashMap<>();

        try {
            // 获取ktr转换文件绝对路径
            File ktrfile = new File(this.getClass().getResource(getDataImportKtrClasspath()).toURI());
            System.out.println(ktrfile.getAbsolutePath());
            // 导入数据
            dataImportExportService.fileDataImport(file, ktrfile);

            resultMap.put("status", ResponseCode.SUCCESS);
            resultMap.put("msg", "导入成功");
        } catch (Exception exp) {
            exp.printStackTrace();
            resultMap.put("status", ResponseCode.ERROR);
            resultMap.put("msg", exp.getLocalizedMessage());
        }

        return resultMap;
    }

    /**
     * 使用ktr导出数据。
     * @param response
     * @throws Exception
     */
    @RequestMapping(value = "/dataExport", method = RequestMethod.GET)
    public void dataExport(HttpServletResponse response) throws Exception {
        dataExport(response, null);
    }

    @RequestMapping(value = "/dataExportExt", method = RequestMethod.GET)
    public void dataExport(HttpServletResponse response, @RequestParam Map<String, Object> param) throws Exception {
        // 1、使用ktr转换获取输出文件
        File ktrfile = new File(this.getClass().getResource(getDataExportKtrClasspath()).toURI());
        File outputfile = null;
        if (!CollectionUtils.isEmpty(param)) {
            outputfile = dataImportExportService.fileDataOutput(
                    getDataExportFilename(),
                    ktrfile,
                    param);
        } else {
            outputfile = dataImportExportService.fileDataOutput(
                    getDataExportFilename(),
                    ktrfile);
        }

        System.out.println(outputfile.getName());
        System.out.println(outputfile.getAbsolutePath());

        String filePath = outputfile.getAbsolutePath();
//        String fp[] = filePath.split(File.separator);
//        String fileName = fp[fp.length - 1];

        // TODO：使用ktr获取导出数据

        response.setHeader("conent-type", "application/octet-stream");
        response.setContentType("application/octet-stream");
        response.setHeader("Content-Disposition", "attachment; filename=" + "东东");

        OutputStream os = response.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(os);

        InputStream is = null;

        is = new FileInputStream(filePath);
        BufferedInputStream bis = new BufferedInputStream(is);

        int length = 0;
        byte[] temp = new byte[1 * 1024 * 10];

        while ((length = bis.read(temp)) != -1) {
            bos.write(temp, 0, length);
        }
        bos.flush();
        bis.close();
        bos.close();
        is.close();
    }

    /**
     * @return 数据导出的ktr转换文件类路径。
     */
    protected String getDataExportKtrClasspath() {
        // 默认返回异常，子类如果要使用导出功能，必须覆写此方法，指定ktr文件类路径
        throw new RuntimeException("必须override，并指定ktr classpath");
    }

    /**
     * @return 导出文件名。
     */
    protected String getDataExportFilename() {
        // 默认返回异常，子类如果要使用导出功能，必须覆写此方法，指定导出的文件路径名
        throw new RuntimeException("必须override，并指定导出文件名");
    }

    /**
     * @return 数据导入的ktr转换文件类路径。
     */
    protected String getDataImportKtrClasspath() {
        // 默认返回异常，子类如果要使用导入功能，必须覆写此方法，指定ktr文件类路径
        throw new RuntimeException("必须override，并指定ktr classpath");
    }


    public static class ExcelFileOutput {
        private String fileName;
        private List<Map<String, Object>> sheetnames = new ArrayList<>();

        public String getFileName() {
            return fileName;
        }

        public void setFileName(String fileName) {
            this.fileName = fileName;
        }

        public List<Map<String, Object>> getSheetnames() {
            return sheetnames;
        }

        public void setSheetnames(List<Map<String, Object>> sheetnames) {
            this.sheetnames = sheetnames;
        }
    }

    /**
     * 上传Excel文件，返回文件全路径名，工作区名称列表。
     * @param file
     * @return
     * @throws Exception
     */
    @RequestMapping(value = "/uploadFile", method = RequestMethod.POST)
    public ExcelFileOutput fileUpload(MultipartFile file) throws Exception {
        // 返回对象
        ExcelFileOutput rs = new ExcelFileOutput();

        // 上传文件
        File file1 = dataImportExportService.uploadFile(file);
        // 获取文件的sheet
        Workbook book = Workbook.getWorkbook(file1);
        for (Sheet sheet : book.getSheets()) {
            String sheetname = sheet.getName();
            Map<String, Object> s = new HashMap<>();
            s.put("name", sheetname);
            rs.getSheetnames().add(s);
        }

        rs.setFileName(file1.getAbsolutePath());
        return rs;
    }

}