From 20bdcd78260be2fa6d126f3e5ee4074058715942 Mon Sep 17 00:00:00 2001 From: KaNi-04 <136799210+KaNi-04@users.noreply.github.com> Date: Mon, 17 Aug 2026 10:51:19 +0530 Subject: [PATCH] getDrainReport Query changed --- .../manhole/service/ManHoleActivity.java | 1324 +++++++++-------- .../controller/APIPenaltyControllerPOS.java | 88 +- 2 files changed, 714 insertions(+), 698 deletions(-) diff --git a/src/main/java/in/gov/chennaicorporation/mobileservice/manhole/service/ManHoleActivity.java b/src/main/java/in/gov/chennaicorporation/mobileservice/manhole/service/ManHoleActivity.java index 49676257..a453f70f 100644 --- a/src/main/java/in/gov/chennaicorporation/mobileservice/manhole/service/ManHoleActivity.java +++ b/src/main/java/in/gov/chennaicorporation/mobileservice/manhole/service/ManHoleActivity.java @@ -40,25 +40,24 @@ import in.gov.chennaicorporation.mobileservice.gccactivity.service.DateTimeUtil; @Service public class ManHoleActivity { private JdbcTemplate jdbcManHoleTemplate; - + private final Environment environment; private String fileBaseUrl; - + private static final String CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; - private static final int STRING_LENGTH = 15; - private static final Random RANDOM = new SecureRandom(); - - @Autowired + private static final int STRING_LENGTH = 15; + private static final Random RANDOM = new SecureRandom(); + + @Autowired public void setDataSource(@Qualifier("mysqlGccManHoleSource") DataSource ManHoleDataSource) { this.jdbcManHoleTemplate = new JdbcTemplate(ManHoleDataSource); } - - @Autowired + + @Autowired public ManHoleActivity(Environment environment) { this.environment = environment; - this.fileBaseUrl=environment.getProperty("fileBaseUrl"); + this.fileBaseUrl = environment.getProperty("fileBaseUrl"); } - public static String generateRandomString() { StringBuilder result = new StringBuilder(STRING_LENGTH); @@ -67,7 +66,7 @@ public class ManHoleActivity { } return result.toString(); } - + public static String generateRandomFileString(int lenthval) { StringBuilder result = new StringBuilder(lenthval); for (int i = 0; i < lenthval; i++) { @@ -118,9 +117,9 @@ public class ManHoleActivity { // Datetime string String datetimetxt = DateTimeUtil.getCurrentDateTime(); - - datetimetxt = datetimetxt + "_"+ generateRandomFileString(6); // Attached Random text - + + datetimetxt = datetimetxt + "_" + generateRandomFileString(6); // Attached Random text + // File name String fileName = name + "_" + id + "_" + datetimetxt + "_" + file.getOriginalFilename(); fileName = fileName.replaceAll("\\s+", ""); // Remove space on filename @@ -134,31 +133,29 @@ public class ManHoleActivity { // Get the bytes of the file byte[] bytes = file.getBytes(); - - if(filetype.equalsIgnoreCase("image")) - { + + if (filetype.equalsIgnoreCase("image")) { // Compress the image BufferedImage image = ImageIO.read(new ByteArrayInputStream(bytes)); byte[] compressedBytes = compressImage(image, 0.5f); // Compress with 50% quality // Write the bytes to the file Files.write(path, compressedBytes); - } - else { + } else { // Write the bytes to the file Files.write(path, bytes); } - // Get current date & time - LocalDateTime now = LocalDateTime.now(); - - // Format date-time (optional) - DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); - - System.out.println("Date: "+ now.format(formatter)); - System.out.println("Activity: ManHole"); - System.out.println("File Type: " + filetype); - System.out.println("File Upload Path: " + filePath); - System.out.println("File Path: " + filepath_txt); - + // Get current date & time + LocalDateTime now = LocalDateTime.now(); + + // Format date-time (optional) + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + System.out.println("Date: " + now.format(formatter)); + System.out.println("Activity: ManHole"); + System.out.println("File Type: " + filetype); + System.out.println("File Upload Path: " + filePath); + System.out.println("File Path: " + filepath_txt); + return filepath_txt; } catch (IOException e) { @@ -167,133 +164,133 @@ public class ManHoleActivity { return "error"; } } - + public String getWardByLoginId(String loginid, String type) { - String sqlQuery = "SELECT `ward` FROM gcc_penalty_hoardings.`hoading_user_list` WHERE `userid` = ? AND `type` = ? LIMIT 1"; - - // Query the database using queryForList - List> results = jdbcManHoleTemplate.queryForList(sqlQuery, loginid, type); - - // Check if results is not empty and extract the ward value - if (!results.isEmpty()) { - // Extract the ward value from the first result - return (String) results.get(0).get("ward"); - } - - // Handle the case where no result is found - return "000"; // or return null based on your needs + String sqlQuery = "SELECT `ward` FROM gcc_penalty_hoardings.`hoading_user_list` WHERE `userid` = ? AND `type` = ? LIMIT 1"; + + // Query the database using queryForList + List> results = jdbcManHoleTemplate.queryForList(sqlQuery, loginid, type); + + // Check if results is not empty and extract the ward value + if (!results.isEmpty()) { + // Extract the ward value from the first result + return (String) results.get(0).get("ward"); + } + + // Handle the case where no result is found + return "000"; // or return null based on your needs } - + /* + * public List> getDrainList(String loginid) { + * + * String ward = getWardByLoginId(loginid,"ae"); + * + * String sql = "SELECT *, " + * + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " + * + "FROM `drain_master` WHERE `ward`= ? AND isactive = 1 AND isdelete = 0 "; + * List> result = jdbcManHoleTemplate.queryForList(sql, + * ward); + * + * Map response = new HashMap<>(); + * response.put("status", "Success"); + * response.put("message", "Drain List."); + * response.put("data", result); + * + * return Collections.singletonList(response); + * } + */ + public List> getDrainList(String loginid) { - - String ward = getWardByLoginId(loginid,"ae"); - - String sql = "SELECT *, " - + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " - + "FROM `drain_master` WHERE `ward`= ? AND isactive = 1 AND isdelete = 0 "; - List> result = jdbcManHoleTemplate.queryForList(sql, ward); - + String ward = getWardByLoginId(loginid, "ae"); + + // 1. Fetch all drains for this ward + String sqlDrain = "SELECT *, " + + " CONCAT('" + fileBaseUrl + "/gccofficialapp/files', `file`) AS file_url " + + " FROM `drain_master` WHERE `ward`= ? AND isactive = 1 AND isdelete = 0"; + + List> drains = jdbcManHoleTemplate.queryForList(sqlDrain, ward); + List> finalList = new ArrayList<>(); + + for (Map drain : drains) { + Map drainResponse = new HashMap<>(); + drainResponse.putAll(drain); // add drain fields + + String drainId = drain.get("drain_id").toString(); + + // 2. Fetch manholes for this drain + String sqlManhole = "SELECT manhole_id FROM manhole_master WHERE drain_id = ? AND isactive=1 AND isdelete=0"; + List> manholes = jdbcManHoleTemplate.queryForList(sqlManhole, drainId); + + int totalManholes = manholes.size(); + int completedCount = 0; + int pendingCount = 0; + + // 3. Check before & after activities for each manhole + for (Map manhole : manholes) { + Object manholeId = manhole.get("manhole_id"); + + // Before + String sqlBefore = "SELECT COUNT(*) FROM before_activity " + + "WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; + int beforeCount = jdbcManHoleTemplate.queryForObject(sqlBefore, Integer.class, manholeId, drainId); + + // After + String sqlAfter = "SELECT COUNT(*) FROM after_activity " + + "WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; + int afterCount = jdbcManHoleTemplate.queryForObject(sqlAfter, Integer.class, manholeId, drainId); + + if (beforeCount > 0 && afterCount > 0) { + completedCount++; + } else { + pendingCount++; + } + } + + // 4. Percentages + double percentCompleted = (totalManholes > 0) ? (completedCount * 100.0 / totalManholes) : 0.0; + double percentPending = (totalManholes > 0) ? (pendingCount * 100.0 / totalManholes) : 0.0; + + // 5. Drain status + String drainStatus = (completedCount == totalManholes && totalManholes > 0) ? "Completed" : "Pending"; + + // 6. Add stats + drainResponse.put("total_manholes", totalManholes); + drainResponse.put("completed", completedCount); + drainResponse.put("pending", pendingCount); + drainResponse.put("percent_completed", String.format("%.2f", percentCompleted)); + drainResponse.put("percent_pending", String.format("%.2f", percentPending)); + drainResponse.put("status", drainStatus); + + finalList.add(drainResponse); + } + Map response = new HashMap<>(); - response.put("status", "Success"); - response.put("message", "Drain List."); - response.put("data", result); - - return Collections.singletonList(response); - } - */ - - public List> getDrainList(String loginid) { - String ward = getWardByLoginId(loginid, "ae"); - - // 1. Fetch all drains for this ward - String sqlDrain = "SELECT *, " - + " CONCAT('" + fileBaseUrl + "/gccofficialapp/files', `file`) AS file_url " - + " FROM `drain_master` WHERE `ward`= ? AND isactive = 1 AND isdelete = 0"; - - List> drains = jdbcManHoleTemplate.queryForList(sqlDrain, ward); - List> finalList = new ArrayList<>(); - - for (Map drain : drains) { - Map drainResponse = new HashMap<>(); - drainResponse.putAll(drain); // add drain fields - - String drainId = drain.get("drain_id").toString(); - - // 2. Fetch manholes for this drain - String sqlManhole = "SELECT manhole_id FROM manhole_master WHERE drain_id = ? AND isactive=1 AND isdelete=0"; - List> manholes = jdbcManHoleTemplate.queryForList(sqlManhole, drainId); - - int totalManholes = manholes.size(); - int completedCount = 0; - int pendingCount = 0; - - // 3. Check before & after activities for each manhole - for (Map manhole : manholes) { - Object manholeId = manhole.get("manhole_id"); - - // Before - String sqlBefore = "SELECT COUNT(*) FROM before_activity " - + "WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; - int beforeCount = jdbcManHoleTemplate.queryForObject(sqlBefore, Integer.class, manholeId, drainId); - - // After - String sqlAfter = "SELECT COUNT(*) FROM after_activity " - + "WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; - int afterCount = jdbcManHoleTemplate.queryForObject(sqlAfter, Integer.class, manholeId, drainId); - - if (beforeCount > 0 && afterCount > 0) { - completedCount++; - } else { - pendingCount++; - } - } - - // 4. Percentages - double percentCompleted = (totalManholes > 0) ? (completedCount * 100.0 / totalManholes) : 0.0; - double percentPending = (totalManholes > 0) ? (pendingCount * 100.0 / totalManholes) : 0.0; - - // 5. Drain status - String drainStatus = (completedCount == totalManholes && totalManholes > 0) ? "Completed" : "Pending"; - - // 6. Add stats - drainResponse.put("total_manholes", totalManholes); - drainResponse.put("completed", completedCount); - drainResponse.put("pending", pendingCount); - drainResponse.put("percent_completed", String.format("%.2f", percentCompleted)); - drainResponse.put("percent_pending", String.format("%.2f", percentPending)); - drainResponse.put("status", drainStatus); - - finalList.add(drainResponse); - } - - Map response = new HashMap<>(); - response.put("status", "Success"); - response.put("message", "Drain List."); - response.put("data", finalList); - - return Collections.singletonList(response); + response.put("status", "Success"); + response.put("message", "Drain List."); + response.put("data", finalList); + + return Collections.singletonList(response); } - + @Transactional public String duplicateDrainCheck(String street_id, String drain_side) { - try { + try { - String checkSql = "SELECT COUNT(*) FROM drain_master WHERE street_id = ? AND `drain_side`= ? AND isactive = 1 AND isdelete = 0 "; + String checkSql = "SELECT COUNT(*) FROM drain_master WHERE street_id = ? AND `drain_side`= ? AND isactive = 1 AND isdelete = 0 "; - Integer count = jdbcManHoleTemplate.queryForObject( - checkSql, - Integer.class, - new Object[]{street_id, drain_side} - ); + Integer count = jdbcManHoleTemplate.queryForObject( + checkSql, + Integer.class, + new Object[] { street_id, drain_side }); - return (count != null && count > 0) ? "true" : "false"; + return (count != null && count > 0) ? "true" : "false"; - } catch (NumberFormatException e) { - return "false"; - } + } catch (NumberFormatException e) { + return "false"; + } } - + public List> saveDrain( String drain_side, String drain_type, @@ -301,545 +298,566 @@ public class ManHoleActivity { String drain_width, String drain_depth, String manhole_count, - String zone, - String ward, - String street_name, - String street_id, - String road_type, - String latitude, - String longitude, - String inby, - MultipartFile file - ) { - + String zone, + String ward, + String street_name, + String street_id, + String road_type, + String latitude, + String longitude, + String inby, + MultipartFile file) { + String action = "New Drain"; - - Map response = new HashMap<>(); - List> result = new ArrayList<>(); - + + Map response = new HashMap<>(); + List> result = new ArrayList<>(); + // Check Duplicate - if(duplicateDrainCheck(street_id,drain_side).equalsIgnoreCase("true")) { + if (duplicateDrainCheck(street_id, drain_side).equalsIgnoreCase("true")) { + response.put("status", "error"); + response.put("message", "Duplicate drain identified!"); + result.add(response); + return result; // stop execution, don’t insert + } + + String filetxt = street_id + "_SWD"; + + String filetype = "image"; + + String drainIMG = fileUpload("Drain", filetxt, file, filetype); + + if ("error".equalsIgnoreCase(drainIMG)) { + response.put("Drain", "upload image"); + response.put("status", "error"); + response.put("message", "Drain image upload failed."); + result.add(response); + return result; + } + + KeyHolder keyHolder = new GeneratedKeyHolder(); + + String insertSql = "INSERT INTO `drain_master` (`drain_side`,`drain_type`,`drain_length`,`drain_width`,`drain_depth`," + + "`manhole_count`,`zone`,`ward`,`street_name`,`street_id`,`road_type`,`latitude`,`longitude`,`inby`,`file`) " + + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; + + int affectedRows = jdbcManHoleTemplate.update(connection -> { + PreparedStatement ps = connection.prepareStatement(insertSql, new String[] { "drain_id" }); + int i = 1; + ps.setString(i++, drain_side); + ps.setString(i++, drain_type); + ps.setString(i++, drain_length); + ps.setString(i++, drain_width); + ps.setString(i++, drain_depth); + ps.setInt(i++, (manhole_count == null || manhole_count.trim().isEmpty()) + ? 1 + : Integer.parseInt(manhole_count)); + ps.setString(i++, zone); + ps.setString(i++, ward); + ps.setString(i++, street_name); + ps.setString(i++, street_id); + ps.setString(i++, road_type); + ps.setString(i++, latitude); + ps.setString(i++, longitude); + ps.setString(i++, inby); + ps.setString(i++, drainIMG); + + return ps; + }, keyHolder); + + if (affectedRows > 0) { + int lastInsertId = keyHolder.getKey().intValue(); + response.put("ManHole", action + " insertId: " + lastInsertId); + response.put("status", "success"); + response.put("message", action + " inserted successfully."); + } else { + response.put("ManHole", action + " insertId error!"); response.put("status", "error"); - response.put("message", "Duplicate drain identified!"); - result.add(response); - return result; // stop execution, don’t insert + response.put("message", action + " insert failed."); } - - String filetxt = street_id+"_SWD"; - - String filetype = "image"; - - String drainIMG = fileUpload("Drain", filetxt, file, filetype); - - if ("error".equalsIgnoreCase(drainIMG)) { - response.put("Drain", "upload image"); - response.put("status", "error"); - response.put("message", "Drain image upload failed."); - result.add(response); - return result; - } - - KeyHolder keyHolder = new GeneratedKeyHolder(); - - String insertSql = "INSERT INTO `drain_master` (`drain_side`,`drain_type`,`drain_length`,`drain_width`,`drain_depth`," - + "`manhole_count`,`zone`,`ward`,`street_name`,`street_id`,`road_type`,`latitude`,`longitude`,`inby`,`file`) " - + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"; - - int affectedRows = jdbcManHoleTemplate.update(connection -> { - PreparedStatement ps = connection.prepareStatement(insertSql, new String[]{"drain_id"}); - int i = 1; - ps.setString(i++, drain_side); - ps.setString(i++, drain_type); - ps.setString(i++, drain_length); - ps.setString(i++, drain_width); - ps.setString(i++, drain_depth); - ps.setInt(i++, (manhole_count == null || manhole_count.trim().isEmpty()) - ? 1 - : Integer.parseInt(manhole_count)); - ps.setString(i++, zone); - ps.setString(i++, ward); - ps.setString(i++, street_name); - ps.setString(i++, street_id); - ps.setString(i++, road_type); - ps.setString(i++, latitude); - ps.setString(i++, longitude); - ps.setString(i++, inby); - ps.setString(i++, drainIMG); - - return ps; - }, keyHolder); - - if (affectedRows > 0) { - int lastInsertId = keyHolder.getKey().intValue(); - response.put("ManHole", action + " insertId: " + lastInsertId); - response.put("status", "success"); - response.put("message", action + " inserted successfully."); - } else { - response.put("ManHole", action + " insertId error!"); - response.put("status", "error"); - response.put("message", action + " insert failed."); - } - - result.add(response); - return result; - } - + + result.add(response); + return result; + } + /* - public List> getManHoleList(String loginid, String swdid) { - - String sql = "SELECT * FROM `manhole_master` WHERE `swdid`= ?"; - List> result = jdbcManHoleTemplate.queryForList(sql, swdid); - - Map response = new HashMap<>(); - response.put("status", "Success"); - response.put("message", "ManHole List."); - response.put("data", result); - - return Collections.singletonList(response); - } - - public List> getManHoleBeforeStatus(String manhole_id) { - - String sql = "SELECT *," - + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " - + " FROM `before_activity` WHERE `manhole_id`= ?"; - List> result = jdbcManHoleTemplate.queryForList(sql, manhole_id); - - Map response = new HashMap<>(); - response.put("status", "Success"); - response.put("message", "ManHole before activity list."); - response.put("data", result); - - return Collections.singletonList(response); - } - - public List> getManHoleAfterStatus(String manhole_id) { - - String sql = "SELECT *," - + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " - + " FROM `after_activity` WHERE `manhole_id`= ?"; - List> result = jdbcManHoleTemplate.queryForList(sql, manhole_id); - - Map response = new HashMap<>(); - response.put("status", "Success"); - response.put("message", "ManHole before activity list."); - response.put("data", result); - - return Collections.singletonList(response); - } - */ - + * public List> getManHoleList(String loginid, String swdid) + * { + * + * String sql = "SELECT * FROM `manhole_master` WHERE `swdid`= ?"; + * List> result = jdbcManHoleTemplate.queryForList(sql, + * swdid); + * + * Map response = new HashMap<>(); + * response.put("status", "Success"); + * response.put("message", "ManHole List."); + * response.put("data", result); + * + * return Collections.singletonList(response); + * } + * + * public List> getManHoleBeforeStatus(String manhole_id) { + * + * String sql = "SELECT *," + * + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " + * + " FROM `before_activity` WHERE `manhole_id`= ?"; + * List> result = jdbcManHoleTemplate.queryForList(sql, + * manhole_id); + * + * Map response = new HashMap<>(); + * response.put("status", "Success"); + * response.put("message", "ManHole before activity list."); + * response.put("data", result); + * + * return Collections.singletonList(response); + * } + * + * public List> getManHoleAfterStatus(String manhole_id) { + * + * String sql = "SELECT *," + * + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " + * + " FROM `after_activity` WHERE `manhole_id`= ?"; + * List> result = jdbcManHoleTemplate.queryForList(sql, + * manhole_id); + * + * Map response = new HashMap<>(); + * response.put("status", "Success"); + * response.put("message", "ManHole before activity list."); + * response.put("data", result); + * + * return Collections.singletonList(response); + * } + */ + @Transactional public boolean manHoleDuplicateCheck(String latitudeStr, String longitudeStr) { - try { - double latitude = Double.parseDouble(latitudeStr); - double longitude = Double.parseDouble(longitudeStr); - - System.out.println("Duplicate check latlong:"+ latitude + " | " + longitude); - - String checkSql = "SELECT COUNT(*) FROM manhole_master " + - "WHERE isactive = 1 AND isdelete = 0 " + // fixed delete flag - "AND (6371008.8 * ACOS(" + - "COS(RADIANS(?)) * COS(RADIANS(latitude)) * " + - "COS(RADIANS(longitude) - RADIANS(?)) + " + - "SIN(RADIANS(?)) * SIN(RADIANS(latitude))" + - ")) < 0.5"; - - Integer count = jdbcManHoleTemplate.queryForObject( - checkSql, - Integer.class, - latitude, longitude, latitude - ); - /* - String checkSqlstr = "SELECT COUNT(*) FROM manhole_master " + - "WHERE isactive = 1 AND isdelete = 0 " + // fixed delete flag - "AND (6371008.8 * ACOS(" + - "COS(RADIANS("+latitude+")) * COS(RADIANS(latitude)) * " + - "COS(RADIANS(longitude) - RADIANS("+longitude+")) + " + - "SIN(RADIANS("+latitude+")) * SIN(RADIANS(latitude))" + - ")) < 0.5"; - - System.out.println("Duplicate check sql:"+ checkSqlstr); - */ - return (count != null && count > 0); - - } catch (NumberFormatException e) { - return false; // invalid lat/lon input - } + try { + double latitude = Double.parseDouble(latitudeStr); + double longitude = Double.parseDouble(longitudeStr); + + System.out.println("Duplicate check latlong:" + latitude + " | " + longitude); + + String checkSql = "SELECT COUNT(*) FROM manhole_master " + + "WHERE isactive = 1 AND isdelete = 0 " + // fixed delete flag + "AND (6371008.8 * ACOS(" + + "COS(RADIANS(?)) * COS(RADIANS(latitude)) * " + + "COS(RADIANS(longitude) - RADIANS(?)) + " + + "SIN(RADIANS(?)) * SIN(RADIANS(latitude))" + + ")) < 0.5"; + + Integer count = jdbcManHoleTemplate.queryForObject( + checkSql, + Integer.class, + latitude, longitude, latitude); + /* + * String checkSqlstr = "SELECT COUNT(*) FROM manhole_master " + + * "WHERE isactive = 1 AND isdelete = 0 " + // fixed delete flag + * "AND (6371008.8 * ACOS(" + + * "COS(RADIANS("+latitude+")) * COS(RADIANS(latitude)) * " + + * "COS(RADIANS(longitude) - RADIANS("+longitude+")) + " + + * "SIN(RADIANS("+latitude+")) * SIN(RADIANS(latitude))" + + * ")) < 0.5"; + * + * System.out.println("Duplicate check sql:"+ checkSqlstr); + */ + return (count != null && count > 0); + + } catch (NumberFormatException e) { + return false; // invalid lat/lon input + } } - + @Transactional public boolean manHoleStreetCheck(String drain_id, String street_id) { - try { - String checkSql = "SELECT COUNT(*) FROM `drain_master` " + - "WHERE isactive = 1 AND isdelete = 0 " + // fixed delete flag - "AND drain_id = ? AND street_id = ? "; - - Integer count = jdbcManHoleTemplate.queryForObject( - checkSql, - Integer.class, - drain_id, - street_id - ); - - return (count != null && count == 1); - - } catch (NumberFormatException e) { - return false; // invalid lat/lon input - } + try { + String checkSql = "SELECT COUNT(*) FROM `drain_master` " + + "WHERE isactive = 1 AND isdelete = 0 " + // fixed delete flag + "AND drain_id = ? AND street_id = ? "; + + Integer count = jdbcManHoleTemplate.queryForObject( + checkSql, + Integer.class, + drain_id, + street_id); + + return (count != null && count == 1); + + } catch (NumberFormatException e) { + return false; // invalid lat/lon input + } } @Transactional public List> saveManHole( - String drain_id, - String zone, - String ward, - String street_name, - String street_id, - String latitude, - String longitude, - String inby - ) { - String action = "Save"; - - Map response = new HashMap<>(); - List> result = new ArrayList<>(); - - // 1. Duplicate check - if (manHoleDuplicateCheck(latitude, longitude)) { - response.put("status", "error"); - response.put("message", "Duplicate ManHole identified within 3 meters!"); - result.add(response); - return result; // stop execution, don’t insert - } - - // 2. Drain Street Check - if (!manHoleStreetCheck(drain_id, street_id)) { - response.put("status", "error"); - response.put("message", "Drain Street not mached with current Street!"); - result.add(response); - return result; // stop execution, don’t insert - } - - KeyHolder keyHolder = new GeneratedKeyHolder(); - - String insertSql = "INSERT INTO manhole_master " + - "(drain_id, zone, ward, street_name, street_id, latitude, longitude, inby) " + - "VALUES (?,?,?,?,?,?,?,?)"; - - int affectedRows = jdbcManHoleTemplate.update(connection -> { - PreparedStatement ps = connection.prepareStatement(insertSql, new String[]{"manhole_id"}); - int i = 1; - ps.setString(i++, drain_id); - ps.setString(i++, zone); - ps.setString(i++, ward); - ps.setString(i++, street_name); - ps.setString(i++, street_id); - ps.setString(i++, latitude); - ps.setString(i++, longitude); - ps.setString(i++, inby); - return ps; - }, keyHolder); - - if (affectedRows > 0) { - int lastInsertId = keyHolder.getKey().intValue(); - response.put("ManHole", action + " insertId: " + lastInsertId); - response.put("status", "success"); - response.put("message", action + " inserted successfully."); - } else { - response.put("ManHole", action + " insertId error!"); - response.put("status", "error"); - response.put("message", action + " insert failed."); - } - - result.add(response); - return result; + String drain_id, + String zone, + String ward, + String street_name, + String street_id, + String latitude, + String longitude, + String inby) { + String action = "Save"; + + Map response = new HashMap<>(); + List> result = new ArrayList<>(); + + // 1. Duplicate check + if (manHoleDuplicateCheck(latitude, longitude)) { + response.put("status", "error"); + response.put("message", "Duplicate ManHole identified within 3 meters!"); + result.add(response); + return result; // stop execution, don’t insert + } + + // 2. Drain Street Check + if (!manHoleStreetCheck(drain_id, street_id)) { + response.put("status", "error"); + response.put("message", "Drain Street not mached with current Street!"); + result.add(response); + return result; // stop execution, don’t insert + } + + KeyHolder keyHolder = new GeneratedKeyHolder(); + + String insertSql = "INSERT INTO manhole_master " + + "(drain_id, zone, ward, street_name, street_id, latitude, longitude, inby) " + + "VALUES (?,?,?,?,?,?,?,?)"; + + int affectedRows = jdbcManHoleTemplate.update(connection -> { + PreparedStatement ps = connection.prepareStatement(insertSql, new String[] { "manhole_id" }); + int i = 1; + ps.setString(i++, drain_id); + ps.setString(i++, zone); + ps.setString(i++, ward); + ps.setString(i++, street_name); + ps.setString(i++, street_id); + ps.setString(i++, latitude); + ps.setString(i++, longitude); + ps.setString(i++, inby); + return ps; + }, keyHolder); + + if (affectedRows > 0) { + int lastInsertId = keyHolder.getKey().intValue(); + response.put("ManHole", action + " insertId: " + lastInsertId); + response.put("status", "success"); + response.put("message", action + " inserted successfully."); + } else { + response.put("ManHole", action + " insertId error!"); + response.put("status", "error"); + response.put("message", action + " insert failed."); + } + + result.add(response); + return result; } - + public List> getManHoleList(String loginid, String drain_id) { - // 1. Fetch all manholes for the given drain_id - String sqlManhole = "SELECT * FROM manhole_master WHERE drain_id = ?"; - List> manholes = jdbcManHoleTemplate.queryForList(sqlManhole, drain_id); - - List> finalList = new ArrayList<>(); - - for (Map manhole : manholes) { - Map manholeResponse = new HashMap<>(); - manholeResponse.putAll(manhole); // add all manhole columns - - // 2. Fetch before activity - String sqlBefore = "SELECT *, " - + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " - + "FROM before_activity WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; - List> beforeActivities = jdbcManHoleTemplate.queryForList(sqlBefore, - manhole.get("manhole_id"), drain_id); - - Map beforeData = new HashMap<>(); - if (!beforeActivities.isEmpty()) { - beforeData.put("status", "Completed"); - beforeData.put("details", beforeActivities); - } else { - beforeData.put("status", "Pending"); - beforeData.put("details", Collections.emptyList()); - } - - // 3. Fetch after activity - String sqlAfter = "SELECT *," - + " CONCAT('"+fileBaseUrl+"/gccofficialapp/files', `file`) AS file_url " - + " FROM after_activity WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; - List> afterActivities = jdbcManHoleTemplate.queryForList(sqlAfter, - manhole.get("manhole_id"), drain_id); - - Map afterData = new HashMap<>(); - if (!afterActivities.isEmpty()) { - afterData.put("status", "Completed"); - afterData.put("details", afterActivities); - } else { - afterData.put("status", "Pending"); - afterData.put("details", Collections.emptyList()); - } - - // 4. Overall manhole status - String overallStatus = (!beforeActivities.isEmpty() && !afterActivities.isEmpty()) ? "Completed" : "Pending"; - manholeResponse.put("status", overallStatus); - manholeResponse.put("before", beforeData); - manholeResponse.put("after", afterData); - - finalList.add(manholeResponse); - } - - Map response = new HashMap<>(); - response.put("status", "Success"); - response.put("message", "ManHole List."); - response.put("data", finalList); - - return Collections.singletonList(response); + // 1. Fetch all manholes for the given drain_id + String sqlManhole = "SELECT * FROM manhole_master WHERE drain_id = ?"; + List> manholes = jdbcManHoleTemplate.queryForList(sqlManhole, drain_id); + + List> finalList = new ArrayList<>(); + + for (Map manhole : manholes) { + Map manholeResponse = new HashMap<>(); + manholeResponse.putAll(manhole); // add all manhole columns + + // 2. Fetch before activity + String sqlBefore = "SELECT *, " + + " CONCAT('" + fileBaseUrl + "/gccofficialapp/files', `file`) AS file_url " + + "FROM before_activity WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; + List> beforeActivities = jdbcManHoleTemplate.queryForList(sqlBefore, + manhole.get("manhole_id"), drain_id); + + Map beforeData = new HashMap<>(); + if (!beforeActivities.isEmpty()) { + beforeData.put("status", "Completed"); + beforeData.put("details", beforeActivities); + } else { + beforeData.put("status", "Pending"); + beforeData.put("details", Collections.emptyList()); + } + + // 3. Fetch after activity + String sqlAfter = "SELECT *," + + " CONCAT('" + fileBaseUrl + "/gccofficialapp/files', `file`) AS file_url " + + " FROM after_activity WHERE manhole_id = ? AND drain_id = ? AND isactive=1 AND isdelete=0"; + List> afterActivities = jdbcManHoleTemplate.queryForList(sqlAfter, + manhole.get("manhole_id"), drain_id); + + Map afterData = new HashMap<>(); + if (!afterActivities.isEmpty()) { + afterData.put("status", "Completed"); + afterData.put("details", afterActivities); + } else { + afterData.put("status", "Pending"); + afterData.put("details", Collections.emptyList()); + } + + // 4. Overall manhole status + String overallStatus = (!beforeActivities.isEmpty() && !afterActivities.isEmpty()) ? "Completed" + : "Pending"; + manholeResponse.put("status", overallStatus); + manholeResponse.put("before", beforeData); + manholeResponse.put("after", afterData); + + finalList.add(manholeResponse); + } + + Map response = new HashMap<>(); + response.put("status", "Success"); + response.put("message", "ManHole List."); + response.put("data", finalList); + + return Collections.singletonList(response); } - + @Transactional public String manHoleLocationCheck(String cby, String manhole_id, String latitudeStr, String longitudeStr) { - try { - double latitude = Double.parseDouble(latitudeStr); - double longitude = Double.parseDouble(longitudeStr); - - String checkSql = "SELECT COUNT(*) FROM manhole_master " + - "WHERE manhole_id = ? " + - "AND (6371008.8 * ACOS(" + - "COS(RADIANS(?)) * COS(RADIANS(latitude)) * " + - "COS(RADIANS(longitude) - RADIANS(?)) + " + - "SIN(RADIANS(?)) * SIN(RADIANS(latitude))" + - ")) < 1"; - - Integer count = jdbcManHoleTemplate.queryForObject( - checkSql, - Integer.class, - new Object[]{manhole_id, latitude, longitude, latitude} - ); - - return (count != null && count > 0) ? "true" : "false"; - - } catch (NumberFormatException e) { - return "false"; // invalid lat/lon input - } + try { + double latitude = Double.parseDouble(latitudeStr); + double longitude = Double.parseDouble(longitudeStr); + + String checkSql = "SELECT COUNT(*) FROM manhole_master " + + "WHERE manhole_id = ? " + + "AND (6371008.8 * ACOS(" + + "COS(RADIANS(?)) * COS(RADIANS(latitude)) * " + + "COS(RADIANS(longitude) - RADIANS(?)) + " + + "SIN(RADIANS(?)) * SIN(RADIANS(latitude))" + + ")) < 1"; + + Integer count = jdbcManHoleTemplate.queryForObject( + checkSql, + Integer.class, + new Object[] { manhole_id, latitude, longitude, latitude }); + + return (count != null && count > 0) ? "true" : "false"; + + } catch (NumberFormatException e) { + return "false"; // invalid lat/lon input + } } - + @Transactional public List> saveActivity( - String manhole_id, - String drain_id, - MultipartFile file, - String zone, - String ward, - String street_name, - String street_id, - String latitude, - String longitude, - String inby, - String action, - String beforeActivityId, - String clean_type, - String case_id - ) { - - String filetxt =manhole_id+"_"+drain_id; - - String filetype = "image"; - - Map response = new HashMap<>(); - List> result = new ArrayList<>(); - - // 1. Drain Street Check - if (!manHoleStreetCheck(drain_id, street_id)) { - response.put("status", "error"); - response.put("message", "Drain Street not mached with current Street!"); - result.add(response); - return result; // stop execution, don’t insert - } - - String activityimg = fileUpload(action, filetxt, file, filetype); - // 2. Check file uploaded - if ("error".equalsIgnoreCase(activityimg)) { - response.put("status", "error"); - response.put("message", "ManHole activity insert failed."); - result.add(response); - return result; - } - - String insertBeforeSql = "INSERT INTO before_activity(manhole_id, drain_id, file, zone, ward, street_name, street_id, latitude, longitude, inby, case_id) " - + "VALUES (?,?,?,?,?,?,?,?,?,?,?)"; + String manhole_id, + String drain_id, + MultipartFile file, + String zone, + String ward, + String street_name, + String street_id, + String latitude, + String longitude, + String inby, + String action, + String beforeActivityId, + String clean_type, + String case_id) { + + String filetxt = manhole_id + "_" + drain_id; + + String filetype = "image"; + + Map response = new HashMap<>(); + List> result = new ArrayList<>(); + + // 1. Drain Street Check + if (!manHoleStreetCheck(drain_id, street_id)) { + response.put("status", "error"); + response.put("message", "Drain Street not mached with current Street!"); + result.add(response); + return result; // stop execution, don’t insert + } + + String activityimg = fileUpload(action, filetxt, file, filetype); + // 2. Check file uploaded + if ("error".equalsIgnoreCase(activityimg)) { + response.put("status", "error"); + response.put("message", "ManHole activity insert failed."); + result.add(response); + return result; + } + + String insertBeforeSql = "INSERT INTO before_activity(manhole_id, drain_id, file, zone, ward, street_name, street_id, latitude, longitude, inby, case_id) " + + "VALUES (?,?,?,?,?,?,?,?,?,?,?)"; String insertAfterSql = "INSERT INTO after_activity(manhole_id, drain_id, file, zone, ward, street_name, street_id, latitude, longitude, inby, case_id, before_activity_id, clean_type) " - + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)"; - + + "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)"; + String insertSql = "before".equalsIgnoreCase(action) ? insertBeforeSql : insertAfterSql; - KeyHolder keyHolder = new GeneratedKeyHolder(); - - int affectedRows = jdbcManHoleTemplate.update(connection -> { - PreparedStatement ps = connection.prepareStatement(insertSql, new String[]{"activity_id"}); - int i = 1; - ps.setString(i++, manhole_id); - ps.setString(i++, drain_id); - ps.setString(i++, activityimg); - ps.setString(i++, zone); - ps.setString(i++, ward); - ps.setString(i++, street_name); - ps.setString(i++, street_id); - ps.setString(i++, latitude); - ps.setString(i++, longitude); - ps.setString(i++, inby); - ps.setString(i++, case_id); - - if ("after".equalsIgnoreCase(action)) { - ps.setString(i++, beforeActivityId); - ps.setString(i++, clean_type); - } - - return ps; - }, keyHolder); - - if (affectedRows > 0) { - int lastInsertId = keyHolder.getKey().intValue(); - response.put("ManHole", action + " insertId: " +lastInsertId); - response.put("status", "success"); - response.put("message", "ManHole " + action + " activity inserted successfully."); - } else { - response.put("ManHole", action + " insertId error!"); - response.put("status", "error"); - response.put("message", "ManHole " + action + " activity insert failed."); - } - - result.add(response); - return result; + KeyHolder keyHolder = new GeneratedKeyHolder(); + + int affectedRows = jdbcManHoleTemplate.update(connection -> { + PreparedStatement ps = connection.prepareStatement(insertSql, new String[] { "activity_id" }); + int i = 1; + ps.setString(i++, manhole_id); + ps.setString(i++, drain_id); + ps.setString(i++, activityimg); + ps.setString(i++, zone); + ps.setString(i++, ward); + ps.setString(i++, street_name); + ps.setString(i++, street_id); + ps.setString(i++, latitude); + ps.setString(i++, longitude); + ps.setString(i++, inby); + ps.setString(i++, case_id); + + if ("after".equalsIgnoreCase(action)) { + ps.setString(i++, beforeActivityId); + ps.setString(i++, clean_type); + } + + return ps; + }, keyHolder); + + if (affectedRows > 0) { + int lastInsertId = keyHolder.getKey().intValue(); + response.put("ManHole", action + " insertId: " + lastInsertId); + response.put("status", "success"); + response.put("message", "ManHole " + action + " activity inserted successfully."); + } else { + response.put("ManHole", action + " insertId error!"); + response.put("status", "error"); + response.put("message", "ManHole " + action + " activity insert failed."); + } + + result.add(response); + return result; } - + public List> getZoneReport() { - String sql = - "SELECT " - + " z.zone," - + " COUNT(t.drain_id) AS total_drain," - + " SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_completed," - + " SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_pending," - + " ROUND(SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_completed_percentage," - + " ROUND(SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_pending_percentage " - + "FROM (" - + " SELECT '01' AS zone UNION ALL" - + " SELECT '02' UNION ALL" - + " SELECT '03' UNION ALL" - + " SELECT '04' UNION ALL" - + " SELECT '05' UNION ALL" - + " SELECT '06' UNION ALL" - + " SELECT '07' UNION ALL" - + " SELECT '08' UNION ALL" - + " SELECT '09' UNION ALL" - + " SELECT '10' UNION ALL" - + " SELECT '11' UNION ALL" - + " SELECT '12' UNION ALL" - + " SELECT '13' UNION ALL" - + " SELECT '14' UNION ALL" - + " SELECT '15'" - + ") z " - + "LEFT JOIN (" - + " SELECT " - + " d.drain_id," - + " d.zone," - + " SUM(d.manhole_count) AS total_manhole," - + " COUNT(DISTINCT CASE " - + " WHEN ba.activity_id IS NOT NULL AND aa.activity_id IS NOT NULL THEN m.manhole_id " - + " END) AS completed_manhole" - + " FROM drain_master d" - + " LEFT JOIN manhole_master m ON d.drain_id = m.drain_id AND m.isactive=1 AND m.isdelete=0" - + " LEFT JOIN before_activity ba ON m.manhole_id = ba.manhole_id AND ba.isactive=1 AND ba.isdelete=0" - + " LEFT JOIN after_activity aa ON m.manhole_id = aa.manhole_id AND aa.isactive=1 AND aa.isdelete=0" - + " WHERE d.isactive = 1 AND d.isdelete = 0" - + " GROUP BY d.drain_id, d.zone" - + ") t ON z.zone = t.zone " - + "GROUP BY z.zone " - + "ORDER BY z.zone"; - - return jdbcManHoleTemplate.queryForList(sql); + String sql = "SELECT " + + " z.zone," + + " COUNT(t.drain_id) AS total_drain," + + " SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_completed," + + " SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_pending," + + " ROUND(SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_completed_percentage," + + " ROUND(SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_pending_percentage " + + "FROM (" + + " SELECT '01' AS zone UNION ALL" + + " SELECT '02' UNION ALL" + + " SELECT '03' UNION ALL" + + " SELECT '04' UNION ALL" + + " SELECT '05' UNION ALL" + + " SELECT '06' UNION ALL" + + " SELECT '07' UNION ALL" + + " SELECT '08' UNION ALL" + + " SELECT '09' UNION ALL" + + " SELECT '10' UNION ALL" + + " SELECT '11' UNION ALL" + + " SELECT '12' UNION ALL" + + " SELECT '13' UNION ALL" + + " SELECT '14' UNION ALL" + + " SELECT '15'" + + ") z " + + "LEFT JOIN (" + + " SELECT " + + " d.drain_id," + + " d.zone," + + " SUM(d.manhole_count) AS total_manhole," + + " COUNT(DISTINCT CASE " + + " WHEN ba.activity_id IS NOT NULL AND aa.activity_id IS NOT NULL THEN m.manhole_id " + + " END) AS completed_manhole" + + " FROM drain_master d" + + " LEFT JOIN manhole_master m ON d.drain_id = m.drain_id AND m.isactive=1 AND m.isdelete=0" + + " LEFT JOIN before_activity ba ON m.manhole_id = ba.manhole_id AND ba.isactive=1 AND ba.isdelete=0" + + " LEFT JOIN after_activity aa ON m.manhole_id = aa.manhole_id AND aa.isactive=1 AND aa.isdelete=0" + + " WHERE d.isactive = 1 AND d.isdelete = 0" + + " GROUP BY d.drain_id, d.zone" + + ") t ON z.zone = t.zone " + + "GROUP BY z.zone " + + "ORDER BY z.zone"; + + return jdbcManHoleTemplate.queryForList(sql); } - + public List> getWardReport(String zone) { - String sql = - "SELECT " - + " t.zone," - + " t.ward," - + " COUNT(t.drain_id) AS total_drain," - + " SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_completed," - + " SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_pending," - + " ROUND(SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_completed_percentage," - + " ROUND(SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_pending_percentage " - + "FROM (" - + " SELECT " - + " d.drain_id," - + " d.zone," - + " d.ward," - + " SUM(d.manhole_count) AS total_manhole," - + " COUNT(DISTINCT CASE " - + " WHEN ba.activity_id IS NOT NULL AND aa.activity_id IS NOT NULL THEN m.manhole_id " - + " END) AS completed_manhole" - + " FROM drain_master d" - + " LEFT JOIN manhole_master m ON d.drain_id = m.drain_id AND m.isactive=1 AND m.isdelete=0" - + " LEFT JOIN before_activity ba ON m.manhole_id = ba.manhole_id AND ba.isactive=1 AND ba.isdelete=0" - + " LEFT JOIN after_activity aa ON m.manhole_id = aa.manhole_id AND aa.isactive=1 AND aa.isdelete=0" - + " WHERE d.isactive = 1 AND d.isdelete = 0" - + " AND d.zone = ?" - + " GROUP BY d.drain_id, d.zone, d.ward" - + ") t " - + "GROUP BY t.zone, t.ward " - + "ORDER BY t.ward"; - - return jdbcManHoleTemplate.queryForList(sql,zone); + String sql = "SELECT " + + " t.zone," + + " t.ward," + + " COUNT(t.drain_id) AS total_drain," + + " SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_completed," + + " SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) AS total_drain_pending," + + " ROUND(SUM(CASE WHEN t.total_manhole = t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_completed_percentage," + + " ROUND(SUM(CASE WHEN t.total_manhole > t.completed_manhole THEN 1 ELSE 0 END) * 100.0 / COUNT(t.drain_id), 2) AS drain_pending_percentage " + + "FROM (" + + " SELECT " + + " d.drain_id," + + " d.zone," + + " d.ward," + + " SUM(d.manhole_count) AS total_manhole," + + " COUNT(DISTINCT CASE " + + " WHEN ba.activity_id IS NOT NULL AND aa.activity_id IS NOT NULL THEN m.manhole_id " + + " END) AS completed_manhole" + + " FROM drain_master d" + + " LEFT JOIN manhole_master m ON d.drain_id = m.drain_id AND m.isactive=1 AND m.isdelete=0" + + " LEFT JOIN before_activity ba ON m.manhole_id = ba.manhole_id AND ba.isactive=1 AND ba.isdelete=0" + + " LEFT JOIN after_activity aa ON m.manhole_id = aa.manhole_id AND aa.isactive=1 AND aa.isdelete=0" + + " WHERE d.isactive = 1 AND d.isdelete = 0" + + " AND d.zone = ?" + + " GROUP BY d.drain_id, d.zone, d.ward" + + ") t " + + "GROUP BY t.zone, t.ward " + + "ORDER BY t.ward"; + + return jdbcManHoleTemplate.queryForList(sql, zone); } - + public List> getDrainReport(String ward) { - String sql = - "SELECT " - + " t.drain_name AS drain, " - + " t.total_manhole AS total_manhole, " - + " t.completed_manhole AS manhole_completed, " - + " (t.total_manhole - t.completed_manhole) AS manhole_pending, " - + " ROUND(t.completed_manhole * 100.0 / t.total_manhole, 2) AS completed_percentage, " - + " ROUND((t.total_manhole - t.completed_manhole) * 100.0 / t.total_manhole, 2) AS pending_percentage " - + "FROM ( " - + " SELECT " - + " CONCAT(d.street_name, '-', d.drain_side) AS drain_name, " - + " d.drain_id, " - + " SUM(d.manhole_count) AS total_manhole, " - + " COUNT(DISTINCT CASE " - + " WHEN ba.activity_id IS NOT NULL AND aa.activity_id IS NOT NULL THEN m.manhole_id " - + " END) AS completed_manhole " - + " FROM drain_master d " - + " LEFT JOIN manhole_master m ON d.drain_id = m.drain_id AND m.isactive=1 AND m.isdelete=0 " - + " LEFT JOIN before_activity ba ON m.manhole_id = ba.manhole_id AND ba.isactive=1 AND ba.isdelete=0 " - + " LEFT JOIN after_activity aa ON m.manhole_id = aa.manhole_id AND aa.isactive=1 AND aa.isdelete=0 " - + " WHERE d.isactive = 1 AND d.isdelete = 0 " - + " AND d.ward = ? " - + " GROUP BY drain_name, d.drain_id " - + ") t " - + "ORDER BY t.drain_name"; - - return jdbcManHoleTemplate.queryForList(sql, ward); + String sql = "SELECT " + + " t.drain_name AS drain, " + + " t.total_manhole, " + + " t.completed_manhole AS manhole_completed, " + + " (t.total_manhole - t.completed_manhole) AS manhole_pending, " + + " ROUND( " + + " t.completed_manhole * 100.0 / NULLIF(t.total_manhole, 0), " + + " 2 " + + " ) AS completed_percentage, " + + " ROUND( " + + " (t.total_manhole - t.completed_manhole) * 100.0 " + + " / NULLIF(t.total_manhole, 0), " + + " 2 " + + " ) AS pending_percentage " + + "FROM ( " + + " SELECT " + + " CONCAT(d.street_name, '-', d.drain_side) AS drain_name, " + + " d.drain_id, " + + " MAX(d.manhole_count) AS total_manhole, " + + " COUNT( " + + " DISTINCT CASE " + + " WHEN ba.activity_id IS NOT NULL " + + " AND aa.activity_id IS NOT NULL " + + " THEN m.manhole_id " + + " END " + + " ) AS completed_manhole " + + " FROM drain_master d " + + " LEFT JOIN manhole_master m " + + " ON d.drain_id = m.drain_id " + + " AND m.isactive = 1 " + + " AND m.isdelete = 0 " + + " LEFT JOIN before_activity ba " + + " ON m.manhole_id = ba.manhole_id " + + " AND ba.isactive = 1 " + + " AND ba.isdelete = 0 " + + " LEFT JOIN after_activity aa " + + " ON m.manhole_id = aa.manhole_id " + + " AND aa.isactive = 1 " + + " AND aa.isdelete = 0 " + + " WHERE " + + " d.isactive = 1 " + + " AND d.isdelete = 0 " + + " AND d.ward = ? " + + " GROUP BY " + + " d.street_name, " + + " d.drain_side, " + + " d.drain_id " + + ") t " + + "ORDER BY t.drain_name;"; + + return jdbcManHoleTemplate.queryForList(sql, ward); } } diff --git a/src/main/java/in/gov/chennaicorporation/mobileservice/penalty/controller/APIPenaltyControllerPOS.java b/src/main/java/in/gov/chennaicorporation/mobileservice/penalty/controller/APIPenaltyControllerPOS.java index 9acc048a..2998f5bb 100644 --- a/src/main/java/in/gov/chennaicorporation/mobileservice/penalty/controller/APIPenaltyControllerPOS.java +++ b/src/main/java/in/gov/chennaicorporation/mobileservice/penalty/controller/APIPenaltyControllerPOS.java @@ -20,44 +20,42 @@ import in.gov.chennaicorporation.mobileservice.penalty.service.PenaltyServicePOS public class APIPenaltyControllerPOS { @Autowired private PenaltyServicePOS penaltyServicePOS; - - @GetMapping(value="/getPenaltyDepartment") + + @GetMapping(value = "/getPenaltyDepartment") public List> getPenaltyDepartment( - @RequestParam(value = "loginId", required = false) String loginId - ) { - return penaltyServicePOS.getPenaltyDepartment(); - } - - @GetMapping(value="/getPenaltytypes") + @RequestParam(value = "loginId", required = false) String loginId) { + return penaltyServicePOS.getPenaltyDepartment(); + } + + @GetMapping(value = "/getPenaltytypes") public List> getPenaltyTypes( @RequestParam(value = "departmentId", required = false) String departmentId, @RequestParam(value = "loginId", required = false) String loginId) { - return penaltyServicePOS.getPenaltyTypeList(departmentId); - } - - @GetMapping(value="/getPenaltyAmount") + return penaltyServicePOS.getPenaltyTypeList(departmentId); + } + + @GetMapping(value = "/getPenaltyAmount") public List> getPenaltyAmount( @RequestParam(value = "categoryId", required = false) String categoryId, @RequestParam(value = "ton", required = false) String ton, - @RequestParam(value = "loginId", required = false) String loginId - ) { - return penaltyServicePOS.getPenaltyAmount(categoryId,ton); - } - - @GetMapping(value="/getOfflineModeTypes") + @RequestParam(value = "loginId", required = false) String loginId) { + return penaltyServicePOS.getPenaltyAmount(categoryId, ton); + } + + @GetMapping(value = "/getOfflineModeTypes") public List> getOfflineModeTypes() { - return penaltyServicePOS.getOfflineModeTypes(); - } - - @GetMapping(value="/getBankList") + return penaltyServicePOS.getOfflineModeTypes(); + } + + @GetMapping(value = "/getBankList") public List> getBankList() { - return penaltyServicePOS.getBankList(); - } - - @PostMapping(value="/generateChallanPOS") + return penaltyServicePOS.getBankList(); + } + + @PostMapping(value = "/generateChallanPOS") public List generateChallan(@RequestParam MultiValueMap formData, - @RequestParam(value = "categoryId", required = false) String categoryId, - @RequestParam(value = "latitude", required = false) String latitude, + @RequestParam(value = "categoryId", required = false) String categoryId, + @RequestParam(value = "latitude", required = false) String latitude, @RequestParam(value = "longitude", required = false) String longitude, @RequestParam(value = "zone", required = false) String zone, @RequestParam(value = "ward", required = false) String ward, @@ -70,26 +68,25 @@ public class APIPenaltyControllerPOS { @RequestParam(value = "tid", required = false) String tid, @RequestParam(value = "mid", required = false) String mid, @RequestParam(value = "serialNumber", required = false) String serialNumber, - @RequestParam(value = "file", required = false) MultipartFile file - ) { + @RequestParam(value = "file", required = false) MultipartFile file) { return penaltyServicePOS.generateChallanPOS(formData, categoryId, latitude, longitude, zone, ward, loginId, violatorName, violatorPhone, violatorCompany, ton, amount, tid, mid, serialNumber, file); } - + @PostMapping("/storeBankTransaction") - public List storeBankTransaction(@RequestBody Map transactionData) { - return penaltyServicePOS.storeBankTransaction(transactionData); - } - + public List storeBankTransaction(@RequestBody Map transactionData) { + return penaltyServicePOS.storeBankTransaction(transactionData); + } + @PostMapping("/storeFailedBankTransaction") - public List storeFailedBankTransaction(@RequestBody Map transactionData) { - return penaltyServicePOS.storeFailedBankTransaction(transactionData); - } - - @PostMapping(value="/storeOfflineTransaction") + public List storeFailedBankTransaction(@RequestBody Map transactionData) { + return penaltyServicePOS.storeFailedBankTransaction(transactionData); + } + + @PostMapping(value = "/storeOfflineTransaction") public List generateOfflineChallan(@RequestParam MultiValueMap formData, - @RequestParam(value = "transactionResponseStatus", required = false) String transactionResponseStatus, - @RequestParam(value = "bankName", required = false) String bankName, + @RequestParam(value = "transactionResponseStatus", required = false) String transactionResponseStatus, + @RequestParam(value = "bankName", required = false) String bankName, @RequestParam(value = "transactionAmount", required = false) String transactionAmount, @RequestParam(value = "txnDate", required = false) String txnDate, @RequestParam(value = "txnTime", required = false) String txnTime, @@ -99,8 +96,9 @@ public class APIPenaltyControllerPOS { @RequestParam(value = "extraInfo3", required = false) String extraInfo3, @RequestParam(value = "txnMode", required = false) String txnMode, @RequestParam(value = "txnId", required = false) String txnId, - @RequestParam(value = "file", required = false) MultipartFile file - ) { - return penaltyServicePOS.storeOfflineTransaction(formData, transactionResponseStatus, bankName, transactionAmount, txnDate, txnTime,branchname,extraInfo,extraInfo2,extraInfo3,txnMode,txnId,file); + @RequestParam(value = "file", required = false) MultipartFile file) { + return penaltyServicePOS.storeOfflineTransaction(formData, transactionResponseStatus, bankName, + transactionAmount, txnDate, txnTime, branchname, extraInfo, extraInfo2, extraInfo3, txnMode, txnId, + file); } }