You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1053 lines
40 KiB
1053 lines
40 KiB
package com.gcc_manpower.gcctonermanagement.controller;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.springframework.beans.factory.annotation.Autowired;
|
|
import org.springframework.stereotype.Controller;
|
|
import org.springframework.ui.Model;
|
|
import org.springframework.web.bind.annotation.GetMapping;
|
|
import org.springframework.web.bind.annotation.PostMapping;
|
|
import org.springframework.web.bind.annotation.RequestMapping;
|
|
import org.springframework.web.bind.annotation.RequestParam;
|
|
import org.springframework.web.bind.annotation.ResponseBody;
|
|
|
|
import org.springframework.beans.factory.annotation.Value;
|
|
import org.springframework.web.multipart.MultipartFile;
|
|
import java.io.File;
|
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
|
import com.fasterxml.jackson.core.type.TypeReference;
|
|
import com.gcc_manpower.gcctonermanagement.service.TonerService;
|
|
import com.gcc_manpower.service.AppUserService;
|
|
import jakarta.servlet.http.HttpSession;
|
|
import jakarta.servlet.http.HttpServletRequest;
|
|
|
|
import org.springframework.security.authentication.AuthenticationManager;
|
|
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
|
|
import org.springframework.security.core.Authentication;
|
|
import org.springframework.security.core.AuthenticationException;
|
|
import org.springframework.security.core.context.SecurityContextHolder;
|
|
import org.springframework.security.web.context.HttpSessionSecurityContextRepository;
|
|
|
|
@Controller
|
|
@RequestMapping("/gcctonermanagement")
|
|
public class TonerController {
|
|
|
|
@Autowired
|
|
private AppUserService appUserService;
|
|
|
|
@Autowired
|
|
private TonerService tonerService;
|
|
|
|
@Autowired
|
|
private AuthenticationManager authenticationManager;
|
|
|
|
@Value("${toner.upload.path:gcctonermanagementfiles}")
|
|
private String tonerUploadPathConfig;
|
|
|
|
@GetMapping({ "", "/", "/upload" })
|
|
public String viewDashboard(Model model, HttpSession session) {
|
|
String username = (String) session.getAttribute("toner_usrName");
|
|
if (username == null) {
|
|
return "redirect:/gcctonermanagement/login";
|
|
}
|
|
|
|
String usrRole = (String) session.getAttribute("toner_usrRole");
|
|
boolean isAdmin = "ADMIN".equalsIgnoreCase(usrRole);
|
|
|
|
// List<Map<String, Object>> vendorDetails =
|
|
// appUserService.getVendorDetailsWithCounts();
|
|
|
|
model.addAttribute("isLoggedIn", true);
|
|
model.addAttribute("isAdmin", isAdmin);
|
|
model.addAttribute("usrName", username);
|
|
model.addAttribute("curPage", "gcctonermanagement");
|
|
// model.addAttribute("vendorDetails", vendorDetails);
|
|
|
|
return "gcctonermanagement/upload";
|
|
}
|
|
|
|
@GetMapping("/login")
|
|
public String login(HttpSession session) {
|
|
return "gcctonermanagement/login";
|
|
}
|
|
|
|
@PostMapping("/api/login")
|
|
@ResponseBody
|
|
public Map<String, Object> validateLogin(
|
|
@RequestParam("usrName") String usrName,
|
|
@RequestParam("usrPass") String usrPass,
|
|
HttpSession session) {
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
|
|
try {
|
|
UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(usrName,
|
|
usrPass);
|
|
Authentication authentication = authenticationManager.authenticate(authenticationToken);
|
|
|
|
SecurityContextHolder.getContext().setAuthentication(authentication);
|
|
session.setAttribute(HttpSessionSecurityContextRepository.SPRING_SECURITY_CONTEXT_KEY,
|
|
SecurityContextHolder.getContext());
|
|
|
|
String role = authentication.getAuthorities().stream()
|
|
.map(auth -> auth.getAuthority().replace("ROLE_", ""))
|
|
.findFirst()
|
|
.orElse("USER");
|
|
|
|
session.setAttribute("toner_usrName", usrName);
|
|
session.setAttribute("toner_usrRole", role);
|
|
session.setMaxInactiveInterval(1800); // 30 minutes session timeout
|
|
response.put("result", true);
|
|
response.put("usrName", usrName);
|
|
} catch (AuthenticationException e) {
|
|
response.put("result", false);
|
|
response.put("error", e.getMessage() != null ? e.getMessage() : "Invalid username or password!");
|
|
}
|
|
|
|
return response;
|
|
}
|
|
|
|
@GetMapping("/logout")
|
|
public String logoutGet(HttpSession session, HttpServletRequest request) {
|
|
SecurityContextHolder.clearContext();
|
|
if (session != null) {
|
|
session.removeAttribute("toner_usrName");
|
|
session.removeAttribute("toner_usrRole");
|
|
session.invalidate();
|
|
}
|
|
request.getSession(true);
|
|
return "redirect:/gcctonermanagement/login";
|
|
}
|
|
|
|
@GetMapping("/api/printers")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getPrinters(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getActivePrinters();
|
|
}
|
|
|
|
@GetMapping("/api/toners")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getToners(@RequestParam("pid") int pid, HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getActiveTonersByPrinter(pid);
|
|
}
|
|
|
|
@GetMapping("/api/departments")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getDepartments(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getActiveDepartments();
|
|
}
|
|
|
|
@GetMapping("/api/zones")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getZones(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getActiveZones();
|
|
}
|
|
|
|
@PostMapping("/api/inward")
|
|
@ResponseBody
|
|
public Map<String, Object> uploadInward(
|
|
@RequestParam("refNo") String refNo,
|
|
@RequestParam("companyName") String companyName,
|
|
@RequestParam("itemsJson") String itemsJson,
|
|
@RequestParam(value = "dcFile", required = false) MultipartFile dcFile,
|
|
HttpSession session) {
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
String username = (String) session.getAttribute("toner_usrName");
|
|
if (username == null) {
|
|
response.put("success", false);
|
|
response.put("error", "Unauthorized access. Please log in.");
|
|
return response;
|
|
}
|
|
|
|
String updatedBy = appUserService.getUserIdByName(username);
|
|
if (updatedBy == null)
|
|
updatedBy = username;
|
|
|
|
if (dcFile == null || dcFile.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Delivery Challan (DC) PDF file is required.");
|
|
return response;
|
|
}
|
|
|
|
if (!isPdfFile(dcFile)) {
|
|
response.put("success", false);
|
|
response.put("error", "Delivery Challan file must be a PDF.");
|
|
return response;
|
|
}
|
|
|
|
try {
|
|
ObjectMapper mapper = new ObjectMapper();
|
|
List<Map<String, Object>> items = mapper.readValue(itemsJson,
|
|
new TypeReference<List<Map<String, Object>>>() {
|
|
});
|
|
|
|
if (items == null || items.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Please enter quantity for at least one model.");
|
|
return response;
|
|
}
|
|
|
|
File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
|
|
if (!uploadDir.exists()) {
|
|
uploadDir.mkdirs();
|
|
}
|
|
|
|
String dcPath = saveUploadedFile(dcFile, "dc", uploadDir);
|
|
|
|
boolean saved = tonerService.saveInwardRegister(
|
|
refNo.trim(), companyName.trim(), items, dcPath, updatedBy);
|
|
|
|
if (saved) {
|
|
response.put("success", true);
|
|
response.put("message", "Inward stock registered successfully.");
|
|
} else {
|
|
deleteFileIfExists(dcPath, uploadDir);
|
|
response.put("success", false);
|
|
response.put("error", "Failed to save inward details in the database.");
|
|
}
|
|
} catch (Exception e) {
|
|
response.put("success", false);
|
|
response.put("error", "An error occurred: " + e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@PostMapping("/api/request")
|
|
@ResponseBody
|
|
public Map<String, Object> uploadRequest(
|
|
@RequestParam("itcellRefNo") String itcellRefNo,
|
|
@RequestParam("deptId") String deptId,
|
|
@RequestParam(value = "zoneId", required = false) String zoneId,
|
|
@RequestParam("itemsJson") String itemsJson,
|
|
@RequestParam(value = "userRequestFile", required = false) MultipartFile userRequestFile,
|
|
HttpSession session) {
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
String username = (String) session.getAttribute("toner_usrName");
|
|
if (username == null) {
|
|
response.put("success", false);
|
|
response.put("error", "Unauthorized access. Please log in.");
|
|
return response;
|
|
}
|
|
|
|
String updatedBy = appUserService.getUserIdByName(username);
|
|
if (updatedBy == null)
|
|
updatedBy = username;
|
|
|
|
if (userRequestFile == null || userRequestFile.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "User Request Letter PDF file is required.");
|
|
return response;
|
|
}
|
|
|
|
if (!isPdfFile(userRequestFile)) {
|
|
response.put("success", false);
|
|
response.put("error", "User Request file must be a PDF.");
|
|
return response;
|
|
}
|
|
|
|
try {
|
|
ObjectMapper mapper = new ObjectMapper();
|
|
List<Map<String, Object>> items = mapper.readValue(itemsJson,
|
|
new TypeReference<List<Map<String, Object>>>() {
|
|
});
|
|
|
|
if (items == null || items.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Please add at least one printer/toner model request entry.");
|
|
return response;
|
|
}
|
|
|
|
File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
|
|
if (!uploadDir.exists()) {
|
|
uploadDir.mkdirs();
|
|
}
|
|
|
|
String urPath = saveUploadedFile(userRequestFile, "user_request", uploadDir);
|
|
|
|
String safeZoneId = (zoneId != null && !zoneId.trim().isEmpty()) ? zoneId.trim() : null;
|
|
boolean saved = tonerService.saveUserRequest(
|
|
itcellRefNo.trim(), deptId.trim(), safeZoneId, items, urPath, updatedBy);
|
|
|
|
if (saved) {
|
|
response.put("success", true);
|
|
response.put("message", "User request saved successfully.");
|
|
} else {
|
|
deleteFileIfExists(urPath, uploadDir);
|
|
response.put("success", false);
|
|
response.put("error", "Failed to save request details in the database.");
|
|
}
|
|
} catch (Exception e) {
|
|
response.put("success", false);
|
|
response.put("error", "An error occurred: " + e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@PostMapping("/api/request/update")
|
|
@ResponseBody
|
|
public Map<String, Object> updateRequest(
|
|
@RequestParam("id") int id,
|
|
@RequestParam("itcellRefNo") String itcellRefNo,
|
|
@RequestParam("deptId") String deptId,
|
|
@RequestParam(value = "zoneId", required = false) String zoneId,
|
|
@RequestParam("pid") int pid,
|
|
@RequestParam("tid") int tid,
|
|
@RequestParam("qtyRequested") int qtyRequested,
|
|
@RequestParam(value = "userRequestFile", required = false) MultipartFile userRequestFile,
|
|
HttpSession session) {
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
String username = (String) session.getAttribute("toner_usrName");
|
|
if (username == null) {
|
|
response.put("success", false);
|
|
response.put("error", "Unauthorized access. Please log in.");
|
|
return response;
|
|
}
|
|
|
|
String updatedBy = appUserService.getUserIdByName(username);
|
|
if (updatedBy == null)
|
|
updatedBy = username;
|
|
|
|
if (itcellRefNo == null || itcellRefNo.trim().isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "IT Cell Reference No. is required.");
|
|
return response;
|
|
}
|
|
|
|
if (deptId == null || deptId.trim().isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Department is required.");
|
|
return response;
|
|
}
|
|
|
|
if (qtyRequested <= 0) {
|
|
response.put("success", false);
|
|
response.put("error", "Quantity requested must be greater than 0.");
|
|
return response;
|
|
}
|
|
|
|
if (userRequestFile != null && !userRequestFile.isEmpty() && !isPdfFile(userRequestFile)) {
|
|
response.put("success", false);
|
|
response.put("error", "User Request file must be a PDF.");
|
|
return response;
|
|
}
|
|
|
|
try {
|
|
File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
|
|
if (!uploadDir.exists()) {
|
|
uploadDir.mkdirs();
|
|
}
|
|
|
|
String urPath = null;
|
|
if (userRequestFile != null && !userRequestFile.isEmpty()) {
|
|
urPath = saveUploadedFile(userRequestFile, "user_request", uploadDir);
|
|
}
|
|
|
|
String safeZoneId = (zoneId != null && !zoneId.trim().isEmpty()) ? zoneId.trim() : null;
|
|
boolean updated = tonerService.updateUserRequest(
|
|
id, itcellRefNo.trim(), deptId.trim(), safeZoneId, pid, tid, qtyRequested, urPath, updatedBy);
|
|
|
|
if (updated) {
|
|
response.put("success", true);
|
|
response.put("message", "User request details updated successfully.");
|
|
} else {
|
|
if (urPath != null) {
|
|
deleteFileIfExists(urPath, uploadDir);
|
|
}
|
|
response.put("success", false);
|
|
response.put("error", "Failed to update user request details in database.");
|
|
}
|
|
} catch (Exception e) {
|
|
response.put("success", false);
|
|
response.put("error", "An error occurred: " + e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@PostMapping("/api/outward")
|
|
@ResponseBody
|
|
public Map<String, Object> uploadOutward(
|
|
@RequestParam("id") int id,
|
|
@RequestParam("qtyIssued") String qtyIssued,
|
|
@RequestParam(value = "finalDeliveredFile", required = false) MultipartFile finalDeliveredFile,
|
|
@RequestParam(value = "userPhotoFile", required = false) MultipartFile userPhotoFile,
|
|
@RequestParam(value = "userPhotoBase64", required = false) String userPhotoBase64,
|
|
HttpSession session) {
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
String username = (String) session.getAttribute("toner_usrName");
|
|
if (username == null) {
|
|
response.put("success", false);
|
|
response.put("error", "Unauthorized access. Please log in.");
|
|
return response;
|
|
}
|
|
|
|
String updatedBy = appUserService.getUserIdByName(username);
|
|
if (updatedBy == null)
|
|
updatedBy = username;
|
|
|
|
if (finalDeliveredFile != null && !finalDeliveredFile.isEmpty()) {
|
|
if (!isPdfFile(finalDeliveredFile)) {
|
|
response.put("success", false);
|
|
response.put("error", "Final Delivered file must be a PDF.");
|
|
return response;
|
|
}
|
|
boolean hasPhoto = (userPhotoFile != null && !userPhotoFile.isEmpty())
|
|
|| (userPhotoBase64 != null && !userPhotoBase64.trim().isEmpty());
|
|
if (!hasPhoto) {
|
|
response.put("success", false);
|
|
response.put("error", "Receiver / User photo is mandatory.");
|
|
return response;
|
|
}
|
|
}
|
|
|
|
if (userPhotoFile != null && !userPhotoFile.isEmpty() && !isImageFile(userPhotoFile)) {
|
|
response.put("success", false);
|
|
response.put("error", "User photo must be a valid image file (JPG, PNG, WEBP).");
|
|
return response;
|
|
}
|
|
|
|
Map<String, Object> req = tonerService.getUserRequestById(id);
|
|
if (req == null) {
|
|
response.put("success", false);
|
|
response.put("error", "Invalid or non-existent request ID: " + id);
|
|
return response;
|
|
}
|
|
|
|
boolean isInitialDelivery = (finalDeliveredFile == null || finalDeliveredFile.isEmpty()) &&
|
|
(userPhotoFile == null || userPhotoFile.isEmpty()) &&
|
|
(userPhotoBase64 == null || userPhotoBase64.trim().isEmpty());
|
|
|
|
if (isInitialDelivery) {
|
|
int issueQty = 0;
|
|
try {
|
|
issueQty = Integer.parseInt(qtyIssued.trim());
|
|
} catch (Exception e) {
|
|
response.put("success", false);
|
|
response.put("error", "Invalid quantity issued value.");
|
|
return response;
|
|
}
|
|
|
|
if (issueQty <= 0) {
|
|
response.put("success", false);
|
|
response.put("error", "Quantity issued must be greater than zero.");
|
|
return response;
|
|
}
|
|
|
|
String pid = String.valueOf(req.get("pid"));
|
|
String tid = String.valueOf(req.get("tid"));
|
|
String modelName = req.get("model_name") != null ? String.valueOf(req.get("model_name")) : "Toner";
|
|
String printerName = req.get("printer_name") != null ? String.valueOf(req.get("printer_name")) : "Printer";
|
|
|
|
int availableStock = tonerService.getAvailableStockForModel(pid, tid);
|
|
|
|
if (availableStock <= 0) {
|
|
response.put("success", false);
|
|
response.put("error", "Cannot issue: No inward stock available for " + printerName + " - " + modelName
|
|
+ ". Please register inward stock before issuing outward delivery.");
|
|
return response;
|
|
}
|
|
|
|
if (issueQty > availableStock) {
|
|
response.put("success", false);
|
|
response.put("error",
|
|
"Cannot issue: Quantity to issue (" + issueQty + ") exceeds available inward stock ("
|
|
+ availableStock + ") for " + printerName + " - " + modelName + ".");
|
|
return response;
|
|
}
|
|
|
|
int requestedQty = 0;
|
|
int alreadyDelivered = 0;
|
|
try {
|
|
if (req.get("qty_requested") != null) {
|
|
requestedQty = Integer.parseInt(String.valueOf(req.get("qty_requested")));
|
|
}
|
|
if (req.get("qty_delivered") != null) {
|
|
alreadyDelivered = Integer.parseInt(String.valueOf(req.get("qty_delivered")));
|
|
}
|
|
} catch (Exception ignored) {
|
|
}
|
|
|
|
int remainingReq = Math.max(0, requestedQty - alreadyDelivered);
|
|
if (issueQty > remainingReq) {
|
|
response.put("success", false);
|
|
response.put("error", "Cannot issue: Quantity to issue (" + issueQty
|
|
+ ") exceeds remaining requested quantity (" + remainingReq + ").");
|
|
return response;
|
|
}
|
|
}
|
|
|
|
try {
|
|
File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
|
|
if (!uploadDir.exists()) {
|
|
uploadDir.mkdirs();
|
|
}
|
|
|
|
String fdPath = saveUploadedFile(finalDeliveredFile, "final_delivered", uploadDir);
|
|
String photoPath = null;
|
|
if (userPhotoFile != null && !userPhotoFile.isEmpty()) {
|
|
photoPath = saveUploadedFile(userPhotoFile, "receiver_photo", uploadDir);
|
|
} else if (userPhotoBase64 != null && !userPhotoBase64.trim().isEmpty()) {
|
|
photoPath = saveBase64Image(userPhotoBase64, "receiver_photo", uploadDir);
|
|
}
|
|
|
|
boolean saved = tonerService.saveOutwardRegister(
|
|
id, qtyIssued.trim(), fdPath, photoPath, updatedBy);
|
|
|
|
if (saved) {
|
|
response.put("success", true);
|
|
response.put("message", "Outward delivery recorded successfully.");
|
|
} else {
|
|
deleteFileIfExists(fdPath, uploadDir);
|
|
deleteFileIfExists(photoPath, uploadDir);
|
|
response.put("success", false);
|
|
response.put("error", "Failed to update outward details in the database.");
|
|
}
|
|
} catch (Exception e) {
|
|
response.put("success", false);
|
|
response.put("error", "An error occurred: " + e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@PostMapping("/api/workorder")
|
|
@ResponseBody
|
|
public Map<String, Object> saveWorkorder(
|
|
@RequestParam("fileNumber") String fileNumber,
|
|
@RequestParam("vendorName") String vendorName,
|
|
@RequestParam("startDate") String startDate,
|
|
@RequestParam("endDate") String endDate,
|
|
@RequestParam("totalQty") String totalQty,
|
|
@RequestParam("itemsJson") String itemsJson,
|
|
@RequestParam("dcFile") MultipartFile dcFile,
|
|
HttpSession session) {
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
String username = (String) session.getAttribute("toner_usrName");
|
|
if (username == null) {
|
|
response.put("success", false);
|
|
response.put("error", "Unauthorized access. Please log in.");
|
|
return response;
|
|
}
|
|
|
|
String updatedBy = appUserService.getUserIdByName(username);
|
|
if (updatedBy == null)
|
|
updatedBy = username;
|
|
|
|
if (dcFile == null || dcFile.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Delivery Challan (DC) PDF upload file is required.");
|
|
return response;
|
|
}
|
|
|
|
if (!isPdfFile(dcFile)) {
|
|
response.put("success", false);
|
|
response.put("error", "Delivery Challan file must be a PDF.");
|
|
return response;
|
|
}
|
|
|
|
// Auto-generate refNo: ITCell-YYYY/MM/DD/XXXX
|
|
java.time.LocalDate today = java.time.LocalDate.now();
|
|
int randomNum = (int) (Math.random() * 9000) + 1000; // 4-digit random number
|
|
String refNo = String.format("ITCell-%d/%02d/%02d/%d", today.getYear(), today.getMonthValue(),
|
|
today.getDayOfMonth(), randomNum);
|
|
|
|
try {
|
|
ObjectMapper mapper = new ObjectMapper();
|
|
List<Map<String, Object>> items = mapper.readValue(itemsJson,
|
|
new TypeReference<List<Map<String, Object>>>() {
|
|
});
|
|
|
|
if (items == null || items.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Please add at least one printer/toner model quantity entry.");
|
|
return response;
|
|
}
|
|
|
|
File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
|
|
if (!uploadDir.exists()) {
|
|
uploadDir.mkdirs();
|
|
}
|
|
|
|
String dcPath = saveUploadedFile(dcFile, "workorder_dc", uploadDir);
|
|
|
|
boolean saved = tonerService.saveWorkorder(
|
|
refNo, fileNumber.trim(), vendorName.trim(),
|
|
startDate, endDate, dcPath, totalQty.trim(), items, updatedBy);
|
|
|
|
if (saved) {
|
|
response.put("success", true);
|
|
response.put("refNo", refNo);
|
|
response.put("message", "Workorder registered successfully.");
|
|
} else {
|
|
deleteFileIfExists(dcPath, uploadDir);
|
|
response.put("success", false);
|
|
response.put("error", "Failed to save workorder details in the database.");
|
|
}
|
|
} catch (Exception e) {
|
|
response.put("success", false);
|
|
response.put("error", "An error occurred: " + e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@GetMapping("/api/report")
|
|
@ResponseBody
|
|
public Map<String, Object> getReportData(HttpSession session) {
|
|
Map<String, Object> response = new HashMap<>();
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
response.put("success", false);
|
|
return response;
|
|
}
|
|
response.put("success", true);
|
|
response.put("metrics", tonerService.getDashboardMetrics());
|
|
response.put("summary", tonerService.getInventorySummary());
|
|
return response;
|
|
}
|
|
|
|
@GetMapping("/api/requests/pending")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getPendingRequestsData(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getPendingRequests();
|
|
}
|
|
|
|
@GetMapping("/api/inward/list")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getInwardListData(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getInwardHistory();
|
|
}
|
|
|
|
@GetMapping("/api/requests/list")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getUserRequestsListData(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getAllUserRequests();
|
|
}
|
|
|
|
@GetMapping("/api/outward/list")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getOutwardListData(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getOutwardHistory();
|
|
}
|
|
|
|
private boolean isPdfFile(MultipartFile file) {
|
|
String originalFilename = file.getOriginalFilename();
|
|
if (originalFilename == null)
|
|
return false;
|
|
return originalFilename.toLowerCase().endsWith(".pdf");
|
|
}
|
|
|
|
private boolean isImageFile(MultipartFile file) {
|
|
String originalFilename = file.getOriginalFilename();
|
|
if (originalFilename == null)
|
|
return false;
|
|
String lower = originalFilename.toLowerCase();
|
|
return lower.endsWith(".jpg") || lower.endsWith(".jpeg") || lower.endsWith(".png") || lower.endsWith(".webp")
|
|
|| lower.endsWith(".gif");
|
|
}
|
|
|
|
private String saveUploadedFile(MultipartFile file, String prefix, File uploadDir) throws Exception {
|
|
if (file == null || file.isEmpty()) {
|
|
return null;
|
|
}
|
|
String originalFilename = file.getOriginalFilename();
|
|
String ext = ".pdf";
|
|
if (originalFilename != null && originalFilename.lastIndexOf('.') > 0) {
|
|
ext = originalFilename.substring(originalFilename.lastIndexOf('.')).toLowerCase();
|
|
}
|
|
|
|
// Clean filename, make it unique
|
|
String savedFilename = prefix + "_" + System.currentTimeMillis() + ext;
|
|
File destFile = new File(uploadDir, savedFilename).getAbsoluteFile();
|
|
file.transferTo(destFile);
|
|
|
|
return "gcctonermanagementfiles/" + savedFilename;
|
|
}
|
|
|
|
private String saveBase64Image(String base64Data, String prefix, File uploadDir) throws Exception {
|
|
if (base64Data == null || base64Data.trim().isEmpty()) {
|
|
return null;
|
|
}
|
|
String cleanData = base64Data.trim();
|
|
String ext = ".jpg";
|
|
if (cleanData.contains("data:image/png;base64,")) {
|
|
ext = ".png";
|
|
cleanData = cleanData.replace("data:image/png;base64,", "");
|
|
} else if (cleanData.contains("data:image/jpeg;base64,")) {
|
|
ext = ".jpg";
|
|
cleanData = cleanData.replace("data:image/jpeg;base64,", "");
|
|
} else if (cleanData.contains("data:image/webp;base64,")) {
|
|
ext = ".webp";
|
|
cleanData = cleanData.replace("data:image/webp;base64,", "");
|
|
} else if (cleanData.startsWith("data:") && cleanData.contains(";base64,")) {
|
|
cleanData = cleanData.substring(cleanData.indexOf(";base64,") + 8);
|
|
}
|
|
|
|
byte[] decodedBytes = java.util.Base64.getDecoder().decode(cleanData);
|
|
String savedFilename = prefix + "_" + System.currentTimeMillis() + ext;
|
|
File destFile = new File(uploadDir, savedFilename).getAbsoluteFile();
|
|
try (java.io.FileOutputStream fos = new java.io.FileOutputStream(destFile)) {
|
|
fos.write(decodedBytes);
|
|
}
|
|
return "gcctonermanagementfiles/" + savedFilename;
|
|
}
|
|
|
|
private void deleteFileIfExists(String webPath, File uploadDir) {
|
|
if (webPath == null || webPath.isEmpty())
|
|
return;
|
|
try {
|
|
String filename = webPath.substring(webPath.lastIndexOf('/') + 1);
|
|
File file = new File(uploadDir, filename).getAbsoluteFile();
|
|
if (file.exists()) {
|
|
file.delete();
|
|
}
|
|
} catch (Exception e) {
|
|
System.err.println("Error deleting file: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
@GetMapping("/api/workorders/active")
|
|
@ResponseBody
|
|
public List<String> getActiveWorkorderRefNos(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return tonerService.getActiveWorkorderRefNos();
|
|
}
|
|
|
|
@GetMapping("/api/workorders/items")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getWorkorderRegisteredItems(
|
|
@RequestParam("refNo") String refNo,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return tonerService.getWorkorderRegisteredItems(refNo);
|
|
}
|
|
|
|
@GetMapping("/api/workorder/history")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getWorkorderRegisterHistory(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return tonerService.getWorkorderRegisterHistory();
|
|
}
|
|
|
|
@PostMapping("/api/workorder-request")
|
|
@ResponseBody
|
|
public Map<String, Object> uploadWorkorderModelRequest(
|
|
@RequestParam("refNo") String refNo,
|
|
@RequestParam("companyName") String companyName,
|
|
@RequestParam("pid") String pid,
|
|
@RequestParam("itemsJson") String itemsJson,
|
|
@RequestParam("emailCopyFile") MultipartFile emailCopyFile,
|
|
HttpSession session) {
|
|
|
|
Map<String, Object> response = new HashMap<>();
|
|
String username = (String) session.getAttribute("toner_usrName");
|
|
if (username == null) {
|
|
response.put("success", false);
|
|
response.put("error", "Unauthorized access. Please log in.");
|
|
return response;
|
|
}
|
|
|
|
String updatedBy = appUserService.getUserIdByName(username);
|
|
if (updatedBy == null)
|
|
updatedBy = username;
|
|
|
|
if (emailCopyFile == null || emailCopyFile.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Email copy PDF upload file is required.");
|
|
return response;
|
|
}
|
|
|
|
if (!isPdfFile(emailCopyFile)) {
|
|
response.put("success", false);
|
|
response.put("error", "Email copy file must be a PDF.");
|
|
return response;
|
|
}
|
|
|
|
try {
|
|
ObjectMapper mapper = new ObjectMapper();
|
|
List<Map<String, Object>> items = mapper.readValue(itemsJson,
|
|
new TypeReference<List<Map<String, Object>>>() {
|
|
});
|
|
|
|
if (items == null || items.isEmpty()) {
|
|
response.put("success", false);
|
|
response.put("error", "Please add at least one toner model quantity entry.");
|
|
return response;
|
|
}
|
|
|
|
File uploadDir = new File(tonerUploadPathConfig).getAbsoluteFile();
|
|
if (!uploadDir.exists()) {
|
|
uploadDir.mkdirs();
|
|
}
|
|
|
|
String ecPath = saveUploadedFile(emailCopyFile, "workorder_request_email",
|
|
uploadDir);
|
|
|
|
boolean saved = tonerService.saveWorkorderModelRequest(
|
|
refNo.trim(), companyName.trim(), pid.trim(), items, ecPath, updatedBy);
|
|
|
|
if (saved) {
|
|
response.put("success", true);
|
|
response.put("message",
|
|
"Workorder model request details saved successfully.");
|
|
} else {
|
|
deleteFileIfExists(ecPath, uploadDir);
|
|
response.put("success", false);
|
|
response.put("error",
|
|
"Failed to save workorder request details in the database.");
|
|
}
|
|
} catch (Exception e) {
|
|
response.put("success", false);
|
|
response.put("error", "An error occurred: " + e.getMessage());
|
|
e.printStackTrace();
|
|
}
|
|
return response;
|
|
}
|
|
|
|
@GetMapping("/api/workorders/active-requests")
|
|
@ResponseBody
|
|
public List<String> getActiveWorkorderRequestRefNos(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return tonerService.getActiveWorkorderRequestRefNos();
|
|
}
|
|
|
|
@GetMapping("/api/workorders/requests")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getWorkorderRequests(
|
|
@RequestParam("refNo") String refNo,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return tonerService.getWorkorderRequests(refNo);
|
|
}
|
|
|
|
@GetMapping("/api/workorder-request/history")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getWorkorderModelRequestHistory(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return new ArrayList<>();
|
|
}
|
|
return tonerService.getWorkorderModelRequestHistory();
|
|
}
|
|
|
|
// Save new department for workorder
|
|
@PostMapping("/api/savedepartment")
|
|
@ResponseBody
|
|
public boolean saveNewDepartment(
|
|
@RequestParam("department") String department,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
|
|
return tonerService.savenewdepartment(department);
|
|
}
|
|
|
|
@PostMapping("/api/savetonermodel")
|
|
@ResponseBody
|
|
public boolean saveNewTonerModel(
|
|
@RequestParam("tonermodel") String tonermodel,
|
|
@RequestParam("pid") int pid,
|
|
@RequestParam(required = false) String partCode,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
|
|
return tonerService.savetonermodel(pid, tonermodel, partCode);
|
|
}
|
|
|
|
@PostMapping("/api/saveprintermodel")
|
|
@ResponseBody
|
|
public boolean saveNewPrinterModel(
|
|
@RequestParam("printermodel") String printermodel,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.saveprintermodel(printermodel);
|
|
}
|
|
|
|
// ================= MASTER UPDATE ENDPOINTS =================
|
|
|
|
@PostMapping("/api/updateprintermodel")
|
|
@ResponseBody
|
|
public boolean updatePrinterModel(
|
|
@RequestParam("id") int id,
|
|
@RequestParam("printermodel") String printermodel,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.updatePrinterModel(id, printermodel);
|
|
}
|
|
|
|
@PostMapping("/api/updatetonermodel")
|
|
@ResponseBody
|
|
public boolean updateTonerModel(
|
|
@RequestParam("id") int id,
|
|
@RequestParam("pid") int pid,
|
|
@RequestParam("tonermodel") String tonermodel,
|
|
@RequestParam(value = "partCode", required = false) String partCode,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.updateTonerModel(id, pid, tonermodel, partCode);
|
|
}
|
|
|
|
@PostMapping("/api/updatedepartment")
|
|
@ResponseBody
|
|
public boolean updateDepartment(
|
|
@RequestParam("id") int id,
|
|
@RequestParam("department") String department,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.updateDepartment(id, department);
|
|
}
|
|
|
|
// ================= MASTER DELETE & RESTORE ENDPOINTS =================
|
|
|
|
@PostMapping("/api/deleteprintermodel")
|
|
@ResponseBody
|
|
public boolean deletePrinterModel(@RequestParam("id") int id, HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.deletePrinterModel(id);
|
|
}
|
|
|
|
@PostMapping("/api/restoreprintermodel")
|
|
@ResponseBody
|
|
public boolean restorePrinterModel(@RequestParam("id") int id, HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.restorePrinterModel(id);
|
|
}
|
|
|
|
@PostMapping("/api/deletetonermodel")
|
|
@ResponseBody
|
|
public boolean deleteTonerModel(@RequestParam("id") int id, HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.deleteTonerModel(id);
|
|
}
|
|
|
|
@PostMapping("/api/restoretonermodel")
|
|
@ResponseBody
|
|
public boolean restoreTonerModel(@RequestParam("id") int id, HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.restoreTonerModel(id);
|
|
}
|
|
|
|
@PostMapping("/api/deletedepartment")
|
|
@ResponseBody
|
|
public boolean deleteDepartment(@RequestParam("id") int id, HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.deleteDepartment(id);
|
|
}
|
|
|
|
@PostMapping("/api/restoredepartment")
|
|
@ResponseBody
|
|
public boolean restoreDepartment(@RequestParam("id") int id, HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return false;
|
|
}
|
|
return tonerService.restoreDepartment(id);
|
|
}
|
|
|
|
// ================= MASTER LISTING ENDPOINTS =================
|
|
|
|
@GetMapping("/api/master/printers")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getMasterPrinters(
|
|
@RequestParam(value = "status", defaultValue = "active") String status,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getMasterPrinters(status);
|
|
}
|
|
|
|
@GetMapping("/api/master/toners")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getMasterToners(
|
|
@RequestParam(value = "status", defaultValue = "active") String status,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getMasterToners(status);
|
|
}
|
|
|
|
@GetMapping("/api/master/departments")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getMasterDepartments(
|
|
@RequestParam(value = "status", defaultValue = "active") String status,
|
|
HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getMasterDepartments(status);
|
|
}
|
|
|
|
@GetMapping("/api/toners/all")
|
|
@ResponseBody
|
|
public List<Map<String, Object>> getAllToners(HttpSession session) {
|
|
if (session.getAttribute("toner_usrName") == null) {
|
|
return java.util.Collections.emptyList();
|
|
}
|
|
return tonerService.getAllActiveToners();
|
|
}
|
|
|
|
}
|