6.3

package com.example.baoli.controller;

import com.example.baoli.entity.ApprovalRecord;
import com.example.baoli.service.ApprovalService;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;
import java.util.Optional;

@RestController
@RequestMapping("/api/approval")
public class ApprovalController {

@Autowired
private ApprovalService approvalService;

@Autowired
private ObjectMapper objectMapper;

@GetMapping
public ResponseEntity<List<ApprovalRecord>> getAllApprovalRecords() {
List<ApprovalRecord> records = approvalService.getAllApprovalRecords();
return ResponseEntity.ok(records);
}

@GetMapping("/{id}")
public ResponseEntity<ApprovalRecord> getApprovalRecordById(@PathVariable Long id) {
Optional<ApprovalRecord> record = approvalService.getApprovalRecordById(id);
return record.map(ResponseEntity::ok)
.orElse(ResponseEntity.notFound().build());
}

@PostMapping
public ResponseEntity<ApprovalRecord> createApprovalRecord(@RequestBody ApprovalRecord approvalRecord) {
try {
ApprovalRecord savedRecord = approvalService.saveApprovalRecord(approvalRecord);
return ResponseEntity.ok(savedRecord);
} catch (Exception e) {
return ResponseEntity.badRequest().build();
}
}

@PutMapping("/{id}")
public ResponseEntity<ApprovalRecord> updateApprovalRecord(@PathVariable Long id, @RequestBody ApprovalRecord approvalRecord) {
approvalRecord.setId(id);
ApprovalRecord updatedRecord = approvalService.saveApprovalRecord(approvalRecord);
return ResponseEntity.ok(updatedRecord);
}

@DeleteMapping("/{id}")
public ResponseEntity<Void> deleteApprovalRecord(@PathVariable Long id) {
approvalService.deleteApprovalRecordById(id);
return ResponseEntity.ok().build();
}

@GetMapping("/status/{status}")
public ResponseEntity<List<ApprovalRecord>> getApprovalRecordsByStatus(@PathVariable String status) {
List<ApprovalRecord> records = approvalService.getApprovalRecordsByStatus(status);
return ResponseEntity.ok(records);
}

@GetMapping("/applicant/{applicant}")
public ResponseEntity<List<ApprovalRecord>> getApprovalRecordsByApplicant(@PathVariable String applicant) {
List<ApprovalRecord> records = approvalService.getApprovalRecordsByApplicant(applicant);
return ResponseEntity.ok(records);
}

@GetMapping("/type/{applicationType}")
public ResponseEntity<List<ApprovalRecord>> getApprovalRecordsByApplicationType(@PathVariable String applicationType) {
List<ApprovalRecord> records = approvalService.getApprovalRecordsByApplicationType(applicationType);
return ResponseEntity.ok(records);
}

@GetMapping("/search")
public ResponseEntity<List<ApprovalRecord>> searchApprovalRecords(@RequestParam(required = false) String applicant,
@RequestParam(required = false) String sparePartName,
@RequestParam(required = false) String status,
@RequestParam(required = false) String applicationType,
@RequestParam(required = false) String urgencyLevel) {
List<ApprovalRecord> records = approvalService.searchApprovalRecords(applicant, sparePartName, status, applicationType, urgencyLevel);
return ResponseEntity.ok(records);
}

/**
* 获取统计信息
*/
@GetMapping("/statistics")
public ResponseEntity<List<Object[]>> getStatistics() {
try {
List<Object[]> statistics = approvalService.getStatistics();
return ResponseEntity.ok(statistics);
} catch (Exception e) {
return ResponseEntity.badRequest().build();
}
}

/**
* 批量导出数据为JSON
*/
@GetMapping("/export")
public ResponseEntity<byte[]> exportData(@RequestParam(required = false) String status,
@RequestParam(required = false) String applicationType) {
try {
List<ApprovalRecord> records;
if (status != null) {
records = approvalService.getApprovalRecordsByStatus(status);
} else if (applicationType != null) {
records = approvalService.getApprovalRecordsByApplicationType(applicationType);
} else {
records = approvalService.getAllApprovalRecords();
}

String jsonData = objectMapper.writeValueAsString(records);
byte[] data = jsonData.getBytes("UTF-8");

String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
String filename = "approval_records_" + timestamp + ".json";

HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
headers.setContentDispositionFormData("attachment", filename);
headers.setContentLength(data.length);

return ResponseEntity.ok()
.headers(headers)
.body(data);
} catch (Exception e) {
return ResponseEntity.badRequest().build();
}
}

/**
* 模版导入功能
*/
@PostMapping("/import")
public ResponseEntity<Map<String, Object>> importData(@RequestParam("file") MultipartFile file) {
try {
if (file.isEmpty()) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "文件为空"));
}

String content = new String(file.getBytes(), "UTF-8");
List<ApprovalRecord> records = objectMapper.readValue(content,
objectMapper.getTypeFactory().constructCollectionType(List.class, ApprovalRecord.class));

int successCount = 0;
int errorCount = 0;
StringBuilder errorMessages = new StringBuilder();

for (ApprovalRecord record : records) {
try {
// 清除ID，让系统重新生成
record.setId(null);
record.setApplicationId(null);
approvalService.saveApprovalRecord(record);
successCount++;
} catch (Exception e) {
errorCount++;
errorMessages.append("记录导入失败: ").append(e.getMessage()).append("; ");
}
}

Map<String, Object> result = Map.of(
"success", true,
"message", "导入完成",
"successCount", successCount,
"errorCount", errorCount,
"errorMessages", errorMessages.toString()
);

return ResponseEntity.ok(result);
} catch (IOException e) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "文件解析失败: " + e.getMessage()));
} catch (Exception e) {
return ResponseEntity.badRequest().body(Map.of("success", false, "message", "导入失败: " + e.getMessage()));
}
}

/**
* 审核通过申请
*/
@PutMapping("/{id}/approve")
public ResponseEntity<ApprovalRecord> approveApplication(@PathVariable Long id, @RequestBody ApprovalRequest request) {
try {
ApprovalRecord approvedRecord = approvalService.approveApplication(id, request.getApprover(), request.getComments());
if (approvedRecord != null) {
return ResponseEntity.ok(approvedRecord);
}
return ResponseEntity.notFound().build();
} catch (RuntimeException e) {
return ResponseEntity.badRequest().build();
}
}

/**
* 驳回申请
*/
@PutMapping("/{id}/reject")
public ResponseEntity<ApprovalRecord> rejectApplication(@PathVariable Long id, @RequestBody ApprovalRequest request) {
ApprovalRecord rejectedRecord = approvalService.rejectApplication(id, request.getApprover(), request.getComments());
if (rejectedRecord != null) {
return ResponseEntity.ok(rejectedRecord);
}
return ResponseEntity.notFound().build();
}

/**
* 检查超时记录
*/
@GetMapping("/overdue")
public ResponseEntity<List<ApprovalRecord>> checkOverdueRecords() {
List<ApprovalRecord> overdueRecords = approvalService.checkOverdueRecords();
return ResponseEntity.ok(overdueRecords);
}

/**
* 发送超时提醒
*/
@PostMapping("/{id}/timeout-reminder")
public ResponseEntity<Void> sendTimeoutReminder(@PathVariable Long id) {
approvalService.sendTimeoutReminder(id);
return ResponseEntity.ok().build();
}

/**
* 维修借用转为维修申领
*/
@PutMapping("/{id}/convert-to-application")
public ResponseEntity<ApprovalRecord> convertBorrowToApplication(@PathVariable Long id, @RequestParam String reason) {
ApprovalRecord convertedRecord = approvalService.convertBorrowToApplication(id, reason);
if (convertedRecord != null) {
return ResponseEntity.ok(convertedRecord);
}
return ResponseEntity.notFound().build();
}

/**
* 批量审核通过
*/
@PutMapping("/batch-approve")
public ResponseEntity<List<ApprovalRecord>> batchApprove(@RequestBody BatchApprovalRequest request) {
try {
List<ApprovalRecord> approvedRecords = approvalService.batchApprove(request.getIds(), request.getApprover(), request.getComments());
return ResponseEntity.ok(approvedRecords);
} catch (Exception e) {
return ResponseEntity.badRequest().build();
}
}

/**
* 批量驳回
*/
@PutMapping("/batch-reject")
public ResponseEntity<List<ApprovalRecord>> batchReject(@RequestBody BatchApprovalRequest request) {
try {
List<ApprovalRecord> rejectedRecords = approvalService.batchReject(request.getIds(), request.getApprover(), request.getComments());
return ResponseEntity.ok(rejectedRecords);
} catch (Exception e) {
return ResponseEntity.badRequest().build();
}
}

// 内部类用于审核请求
public static class ApprovalRequest {
private String approver;
private String comments;

public String getApprover() { return approver; }
public void setApprover(String approver) { this.approver = approver; }

public String getComments() { return comments; }
public void setComments(String comments) { this.comments = comments; }
}

// 内部类用于批量审核请求
public static class BatchApprovalRequest {
private List<Long> ids;
private String approver;
private String comments;

public List<Long> getIds() { return ids; }
public void setIds(List<Long> ids) { this.ids = ids; }

public String getApprover() { return approver; }
public void setApprover(String approver) { this.approver = approver; }

public String getComments() { return comments; }
public void setComments(String comments) { this.comments = comments; }
}
}