Added Roadwar works Dashboards

src/main/java/com/gcc/commissionerreview/configuration/DataSourceConfig.java

@@ -17,11 +17,11 @@ import org.springframework.transaction.annotation.EnableTransactionManagement;
 @EnableTransactionManagement
 public class DataSourceConfig {
 
-	// private static String host = "localhost:3306";
-	// private static String dbpassword = "root";
+	 private static String host = "localhost:3306";
+	 private static String dbpassword = "root";
 
-	private static String host = "gcc-facial-db-instance-1.cf48eqcciziq.ap-south-1.rds.amazonaws.com:3306";
-	private static String dbpassword = "gcc-facial-password";
+//	private static String host = "gcc-facial-db-instance-1.cf48eqcciziq.ap-south-1.rds.amazonaws.com:3306";
+//	private static String dbpassword = "gcc-facial-password";
 
 	public static class MyDataSourceConfig {
 		@Primary
@@ -334,4 +334,16 @@ public class DataSourceConfig {
 		return dataSource;
 	}
 	
+	
+	////////// Works Dashboard //////////////////////
+	@Bean(name = "mysqlWorksDataSource")
+	public DataSource mysqlWorksDataSource() {
+		DriverManagerDataSource dataSource = new DriverManagerDataSource();
+		dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
+		dataSource.setUrl("jdbc:mysql://" + host + "/gcc_works_status");
+		dataSource.setUsername("root");
+		dataSource.setPassword(dbpassword);
+		return dataSource;
+	}
+
 }

src/main/java/com/gcc/commissionerreview/controller/MainController.java

@@ -14,6 +14,7 @@ import org.springframework.stereotype.Controller;
 import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.client.RestTemplate;
 import org.springframework.web.servlet.ModelAndView;
 
@@ -424,4 +425,26 @@ public class MainController {
         return "modules/communityrevenue";
     }
       
+    @GetMapping("/roadworksDashboard")
+    public String worksDashboard() {
+    	return "modules/works/dashboard";
+    }
+    
+    @GetMapping("/roadworksviewdetails")
+    public String worksEstimateDetails(@RequestParam int estid) {
+    	return "modules/works/estimatedetails";
+    }
+    
+    @GetMapping("/roadestimatedetails")
+    public String roadEstimateDetails(@RequestParam int estid,@RequestParam int ref_id) {
+    	return "modules/works/roadworksdetails";
+    }
+    
+    @GetMapping("/roadwarRegisterDashboard")
+    public String roadwarRegisterDashboard()
+    {
+    	return "modules/roadwarweb/roadwarregisterdashboard";
+    }
+    
+
 }

src/main/java/com/gcc/commissionerreview/controller/RoadWarApiController.java

@@ -156,4 +156,24 @@ public class RoadWarApiController {
 	    roadWarService.downloadRoadWarPdf(refId, response);
 	}
 	
+	//for road war register dashboard
+	
+	@GetMapping("/getdashboardsummary")
+	public Map<String, Object> getDashboardSummary(@RequestParam(required = false) String zone,
+			@RequestParam(required = false) String ward, @RequestParam(required = false) Integer roadType,
+			@RequestParam(required = false) String swd) {
+
+		return roadWarService.getDashboardSummary(zone, ward, roadType, swd);
+	}
+
+	@GetMapping("/getroadrecords")
+	public Map<String, Object> getRoadRecords(@RequestParam(required = false) String zone,
+			@RequestParam(required = false) String ward, @RequestParam(required = false) Integer roadType,
+			@RequestParam(required = false) String swd) {
+
+		return roadWarService.getRoadRecords(zone, ward, roadType, swd
+
+		);
+	}
+	
 }

src/main/java/com/gcc/commissionerreview/controller/WorksController.java

@@ -0,0 +1,114 @@
+package com.gcc.commissionerreview.controller;
+
+import com.gcc.commissionerreview.service.WorksService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@RequestMapping("/commissionerreview/api/works")
+
+public class WorksController {
+
+    @Autowired
+    private WorksService worksService ;
+
+
+    @GetMapping("/financial-years")
+    public List<Map<String, Object>> getFinancialYears() {
+        return worksService.getFinancialYears();
+    }
+
+
+    @GetMapping("/work-types")
+    public List<Map<String, Object>> getWorkTypes() {
+        return worksService.getWorkTypes();
+    }
+
+
+    @GetMapping("/road-types")
+    public List<Map<String, Object>> getRoadTypes() {
+        return worksService.getRoadTypes();
+    }
+
+    @GetMapping("/fund-types")
+    public List<Map<String, Object>> getFundTypes() {
+        return worksService.getFundTypes();
+    }
+
+
+    @GetMapping("/progress-status")
+    public List<Map<String, Object>> getProgressStatus() {
+        return worksService.getProgressStatus();
+    }
+
+
+    @GetMapping("/zones")
+    public List<Map<String, Object>> getAllZones() {
+        return worksService.getAllZones();
+    }
+
+    @GetMapping("/wards")
+    public List<Map<String, Object>> getAllWards(int zone) {
+        return worksService.getAllWards(zone);
+    }
+
+
+
+    @GetMapping("/dashboard-details")
+    public ResponseEntity<?> getDashboardSummary(
+
+            @RequestParam(required = false) String financialYear,
+
+            @RequestParam(required = false) Integer workType,
+
+            @RequestParam(required = false) Integer roadType,
+
+            @RequestParam(required = false) Integer fundType,
+
+            @RequestParam(required = false) String progressStatus,
+
+            @RequestParam(required = false) Integer zone,
+
+            @RequestParam(required = false) Integer ward) {
+
+		Map<String, Object> result = worksService.getDashboardDetails(financialYear, workType, roadType, fundType,
+				progressStatus, zone, ward);
+
+        return ResponseEntity.ok(result);
+    }
+
+    @GetMapping("/viewEstimateDetails")
+    public ResponseEntity<?> getDetailsByEstId(@RequestParam int estid) {
+        Map<String, Object> result =worksService.getDetailsByEstId(estid);
+        return ResponseEntity.ok(result);
+    }
+
+
+    @GetMapping("/viewRoadWorks")
+    public List<Map<String, Object>> viewRoadWorks(int estid) {
+        return worksService.viewRoadWorks(estid);
+    }
+    
+    @GetMapping("/roadtabdetails")
+    public List<Map<String, Object>> viewRoadTabDetails(int estid,int ref_id) {
+        return worksService.viewRoadTabDetails(estid, ref_id);
+    }
+    
+    @GetMapping("/progresstabdetails")
+    public List<Map<String, Object>> viewProgressTabDetails(int estid,int ref_id) {
+        return worksService.viewProgressTabDetails(estid, ref_id);
+    }
+    
+    @GetMapping("/getRoadWarDetailsByRoadId")
+	public Map<String, Object> getRoadWarDetailsByRoadId(int estid,int ref_id){
+		return worksService.getRoadWarDetailsByRoadId2(estid, ref_id);
+	}
+
+}

src/main/java/com/gcc/commissionerreview/service/RoadWarService.java

@@ -1500,6 +1500,374 @@ public class RoadWarService {
 	    return p;
 	}
 	
+	// for road war register dashboard
 	
+	 public Map<String, Object> getDashboardSummary(
+	            String zone,
+	            String ward,
+	            Integer roadType,
+	            String swd) {
+
+	        Map<String, Object> response = new HashMap<>();
+
+	        try {
+
+				StringBuilder where = new StringBuilder("""
+						WHERE r.is_active = 1
+						  AND r.is_delete = 0
+						""");
+
+	            List<Object> params = new ArrayList<>();
+
+	            addFilters(where, params, zone, ward, roadType, swd);
+
+	            // ------------------------------------
+	            // 1. Total Roads
+	            // ------------------------------------
+
+	            String totalSql =
+	                    "SELECT COUNT(*) " +
+	                    "FROM road_details_master r " +
+	                    where;
+
+	            Integer totalRoads = jdbcTemplate.queryForObject(
+	                    totalSql,
+	                    params.toArray(),
+	                    Integer.class
+	            );
+
+	            // ------------------------------------
+	            // 2. Zone-wise Road Count
+	            // ------------------------------------
+
+	            String zoneSql = """
+	                    SELECT 
+	                        z.zone_name AS zone,
+	                        COUNT(r.id) AS road_count
+	                    FROM zone_master z
+	                    LEFT JOIN road_details_master r
+	                        ON r.zone = z.zone_name
+	                        AND r.is_active = 1
+	                        AND r.is_delete = 0
+	                    """;
+
+	            StringBuilder zoneWhere = new StringBuilder();
+
+	            List<Object> zoneParams = new ArrayList<>();
+
+	            if (ward != null && !ward.trim().isEmpty()) {
+	                zoneWhere.append(" AND r.ward = ? ");
+	                zoneParams.add(ward);
+	            }
+
+	            if (roadType != null) {
+	                zoneWhere.append(" AND r.road_type = ? ");
+	                zoneParams.add(roadType);
+	            }
+
+	            if (swd != null && !swd.trim().isEmpty()) {
+	                zoneWhere.append(" AND LOWER(TRIM(r.is_swd)) = LOWER(?) ");
+	                zoneParams.add(swd);
+	            }
+
+	            /*
+	             * Important:
+	             * If a particular zone is selected, we still want
+	             * all zones displayed with zero for other zones.
+	             */
+	            if (zone != null && !zone.trim().isEmpty()) {
+	                zoneWhere.append(" AND r.zone = ? ");
+	                zoneParams.add(zone);
+	            }
+
+	            zoneSql += zoneWhere;
+	            zoneSql += """
+	                    WHERE z.is_active = 1
+	                      AND z.is_delete = 0
+	                    GROUP BY z.id, z.zone_name
+	                    ORDER BY z.id
+	                    """;
+
+	            /*
+	             * The above SQL has WHERE after LEFT JOIN condition.
+	             * Because zoneWhere contains r conditions, putting them
+	             * in WHERE would convert LEFT JOIN behavior.
+	             *
+	             * Therefore we use a separate query below.
+	             */
+
+				zoneSql = buildZoneQuery(zone, ward, roadType, swd);
+
+				List<Map<String, Object>> zoneCounts = jdbcTemplate.queryForList(zoneSql,
+						buildZoneParams(zone, ward, roadType, swd).toArray());
+
+	            // ------------------------------------
+	            // 3. Road Type Count
+	            // ------------------------------------
+
+				String roadTypeSql = """
+						SELECT
+						    rt.id AS road_type_id,
+						    rt.road_type AS road_type,
+						    COUNT(r.id) AS road_count
+						FROM road_type_master rt
+						LEFT JOIN road_details_master r
+						    ON r.road_type = rt.id
+						    AND r.is_active = 1
+						    AND r.is_delete = 0
+						""";
+
+				StringBuilder roadTypeCondition = new StringBuilder();
+				List<Object> roadTypeParams = new ArrayList<>();
+
+				addJoinFilters(roadTypeCondition, roadTypeParams, zone, ward, roadType, swd);
+
+				roadTypeSql += roadTypeCondition;
+
+				roadTypeSql += """
+						WHERE rt.is_active = 1
+						  AND rt.is_delete = 0
+						GROUP BY rt.id, rt.road_type
+						ORDER BY rt.id
+						""";
+
+				List<Map<String, Object>> roadTypeCounts = jdbcTemplate.queryForList(roadTypeSql,
+						roadTypeParams.toArray());
+
+	            // ------------------------------------
+	            // 4. SWD Count
+	            // ------------------------------------
+
+				String swdSql = """
+						SELECT
+						    SUM(
+						        CASE
+						            WHEN LOWER(TRIM(r.is_swd)) = 'yes'
+						            THEN 1
+						            ELSE 0
+						        END
+						    ) AS available_count,
+
+						    SUM(
+						        CASE
+						            WHEN LOWER(TRIM(r.is_swd)) = 'no'
+						            THEN 1
+						            ELSE 0
+						        END
+						    ) AS not_available_count
+
+						FROM road_details_master r
+						""";
+
+				StringBuilder swdWhere = new StringBuilder(" WHERE r.is_active = 1 AND r.is_delete = 0 ");
+
+				List<Object> swdParams = new ArrayList<>();
+
+				addFilters(swdWhere, swdParams, zone, ward, roadType, null);
+
+				swdSql += swdWhere;
+
+				Map<String, Object> swdResult = jdbcTemplate.queryForMap(swdSql, swdParams.toArray());
+
+				Map<String, Object> swdCounts = new HashMap<>();
+
+				swdCounts.put("available", swdResult.get("available_count"));
+
+				swdCounts.put("notAvailable", swdResult.get("not_available_count"));
+
+				response.put("status", true);
+				response.put("message", "Dashboard data fetched successfully");
+				response.put("totalRoads", totalRoads);
+				response.put("zoneCounts", zoneCounts);
+				response.put("roadTypeCounts", roadTypeCounts);
+				response.put("swdCounts", swdCounts);
+
+			} catch (Exception e) {
+
+				e.printStackTrace();
+
+				response.put("status", false);
+				response.put("message", "Failed to fetch dashboard data");
+			}
+
+			return response;
+		}
+	 
+	 
+		private void addFilters(StringBuilder where, List<Object> params, String zone, String ward, Integer roadType,
+				String swd) {
+
+			if (zone != null && !zone.trim().isEmpty()) {
+				where.append(" AND r.zone = ? ");
+				params.add(zone);
+			}
+
+			if (ward != null && !ward.trim().isEmpty()) {
+				where.append(" AND r.ward = ? ");
+				params.add(ward);
+			}
+
+			if (roadType != null) {
+				where.append(" AND r.road_type = ? ");
+				params.add(roadType);
+			}
+
+			if (swd != null && !swd.trim().isEmpty()) {
+				where.append(" AND LOWER(TRIM(r.is_swd)) = LOWER(?) ");
+				params.add(swd);
+			}
+		}
+	 
+		private String buildZoneQuery(String zone, String ward, Integer roadType, String swd) {
+
+			StringBuilder sql = new StringBuilder("""
+					SELECT
+					    z.id AS zone_id,
+					    z.zone_name AS zone,
+					    COUNT(r.id) AS road_count
+					FROM zone_master z
+					LEFT JOIN road_details_master r
+					    ON r.zone = z.zone_name
+					    AND r.is_active = 1
+					    AND r.is_delete = 0
+					""");
+
+			if (zone != null && !zone.trim().isEmpty()) {
+				sql.append(" AND r.zone = ? ");
+			}
+
+			if (ward != null && !ward.trim().isEmpty()) {
+				sql.append(" AND r.ward = ? ");
+			}
+
+			if (roadType != null) {
+				sql.append(" AND r.road_type = ? ");
+			}
+
+			if (swd != null && !swd.trim().isEmpty()) {
+				sql.append(" AND LOWER(TRIM(r.is_swd)) = LOWER(?) ");
+			}
+
+			sql.append("""
+					WHERE z.is_active = 1
+					  AND z.is_delete = 0
+					GROUP BY z.id, z.zone_name
+					ORDER BY z.id
+					""");
+
+			return sql.toString();
+		}
+	 
+		private List<Object> buildZoneParams(String zone, String ward, Integer roadType, String swd) {
+
+			List<Object> params = new ArrayList<>();
+
+			if (zone != null && !zone.trim().isEmpty()) {
+				params.add(zone);
+			}
+
+			if (ward != null && !ward.trim().isEmpty()) {
+				params.add(ward);
+			}
+
+			if (roadType != null) {
+				params.add(roadType);
+			}
+
+			if (swd != null && !swd.trim().isEmpty()) {
+				params.add(swd);
+			}
+
+			return params;
+		}
+	 
+		private void addJoinFilters(StringBuilder condition, List<Object> params, String zone, String ward,
+				Integer roadType, String swd) {
+
+			if (zone != null && !zone.trim().isEmpty()) {
+				condition.append(" AND r.zone = ? ");
+				params.add(zone);
+			}
+
+			if (ward != null && !ward.trim().isEmpty()) {
+				condition.append(" AND r.ward = ? ");
+				params.add(ward);
+			}
+
+			if (roadType != null) {
+				condition.append(" AND r.road_type = ? ");
+				params.add(roadType);
+			}
+
+			if (swd != null && !swd.trim().isEmpty()) {
+				condition.append(" AND LOWER(TRIM(r.is_swd)) = LOWER(?) ");
+				params.add(swd);
+			}
+		}
+	 
+		public Map<String, Object> getRoadRecords(String zone, String ward, Integer roadType, String swd) {
+
+			Map<String, Object> response = new HashMap<>();
+
+			try {
+
+				StringBuilder sql = new StringBuilder("""
+						SELECT
+						    r.id,
+						    r.ref_id,
+						    r.road_id,
+						    r.zone,
+						    r.ward,
+						    r.road_name,
+						    r.area_name,
+						    r.locality_name,
+						    r.road_type,
+						    rt.road_type AS road_type_name,
+						    rmm.roadtype_material as road_type_material,
+						    r.road_length,
+						    r.road_row_width,
+						    r.road_avg_width,
+						    r.road_area,
+						    r.is_swd,
+						    r.is_electric_poles,
+						    r.is_streetlight_poles,
+						    r.culvert_bridge_count,
+						    r.details
+						FROM road_details_master r
+						LEFT JOIN road_type_master rt
+						    ON rt.id = r.road_type
+						LEFT JOIN roadtype_material_master rmm
+							ON rmm.id=r.road_type_material
+						WHERE r.is_active = 1
+						  AND r.is_delete = 0
+						""");
+
+				List<Object> params = new ArrayList<>();
+
+				addFilters(sql, params, zone, ward, roadType, swd);
+
+				sql.append("""
+						ORDER BY r.ref_id ASC
+						""");
+
+				List<Map<String, Object>> records = jdbcTemplate.queryForList(sql.toString(), params.toArray());
+
+				response.put("status", true);
+				response.put("message", "Records fetched successfully");
+				response.put("data", records);
+				response.put("recordsTotal", records.size());
+				response.put("recordsFiltered", records.size());
+
+			} catch (Exception e) {
+
+				e.printStackTrace();
+
+				response.put("status", false);
+				response.put("message", "Failed to fetch road records");
+				response.put("data", new ArrayList<>());
+			}
+
+			return response;
+		}
 	
 }

src/main/resources/application.properties

@@ -1,2 +1,2 @@
-spring.profiles.active=prod
-#spring.profiles.active=dev
+#spring.profiles.active=prod
+spring.profiles.active=dev