Implemented endpoint to get consumption by supply hourly

Author: viktorKhan

src/main/java/org/lucoenergia/conluz/domain/consumption/datadis/get/GetDatadisConsumptionRepository.java

@@ -22,4 +22,15 @@ public interface GetDatadisConsumptionRepository {
      */
     List<DatadisConsumption> getDailyConsumptionsByRangeOfDates(@NotNull Supply supply,
                                                                 @NotNull OffsetDateTime startDate, @NotNull OffsetDateTime endDate);
+
+    /**
+     * Retrieves a list of hourly consumption data within a specified date range for the given supply.
+     *
+     * @param supply the supply for which the consumption data is retrieved, must not be null
+     * @param startDate the start date of the range, inclusive, must not be null
+     * @param endDate the end date of the range, inclusive, must not be null
+     * @return a list of {@code DatadisConsumption} objects representing hourly consumption data within the specified date range
+     */
+    List<DatadisConsumption> getHourlyConsumptionsByRangeOfDates(@NotNull Supply supply,
+                                                                 @NotNull OffsetDateTime startDate, @NotNull OffsetDateTime endDate);
 }

src/main/java/org/lucoenergia/conluz/domain/consumption/datadis/get/GetDatadisConsumptionService.java

@@ -24,4 +24,17 @@ public interface GetDatadisConsumptionService {
     List<DatadisConsumption> getDailyConsumptionBySupply(@NotNull SupplyId supplyId,
                                                           @NotNull OffsetDateTime startDate,
                                                           @NotNull OffsetDateTime endDate);
+
+    /**
+     * Retrieves hourly consumption data for a specific supply within a date range.
+     * Access is restricted based on user role and ownership.
+     *
+     * @param supplyId the supply ID for which to retrieve consumption data
+     * @param startDate the start date of the range, inclusive
+     * @param endDate the end date of the range, inclusive
+     * @return a list of hourly consumption data
+     */
+    List<DatadisConsumption> getHourlyConsumptionBySupply(@NotNull SupplyId supplyId,
+                                                           @NotNull OffsetDateTime startDate,
+                                                           @NotNull OffsetDateTime endDate);
 }

src/main/java/org/lucoenergia/conluz/infrastructure/admin/supply/consumption/GetSupplyHourlyConsumptionController.java

@@ -0,0 +1,83 @@
+package org.lucoenergia.conluz.infrastructure.admin.supply.consumption;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.responses.ApiResponses;
+import io.swagger.v3.oas.annotations.security.SecurityRequirement;
+import org.lucoenergia.conluz.domain.consumption.datadis.DatadisConsumption;
+import org.lucoenergia.conluz.domain.consumption.datadis.get.GetDatadisConsumptionService;
+import org.lucoenergia.conluz.domain.shared.SupplyId;
+import org.lucoenergia.conluz.infrastructure.shared.web.apidocs.ApiTag;
+import org.lucoenergia.conluz.infrastructure.shared.web.apidocs.response.BadRequestErrorResponse;
+import org.lucoenergia.conluz.infrastructure.shared.web.apidocs.response.ForbiddenErrorResponse;
+import org.lucoenergia.conluz.infrastructure.shared.web.apidocs.response.InternalServerErrorResponse;
+import org.lucoenergia.conluz.infrastructure.shared.web.apidocs.response.NotFoundErrorResponse;
+import org.lucoenergia.conluz.infrastructure.shared.web.apidocs.response.UnauthorizedErrorResponse;
+import org.springframework.format.annotation.DateTimeFormat;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.OffsetDateTime;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * Controller for retrieving hourly consumption data for a specific supply
+ */
+@RestController
+@RequestMapping("/api/v1/supplies/{id}/consumption/hourly")
+public class GetSupplyHourlyConsumptionController {
+
+    private final GetDatadisConsumptionService getDatadisConsumptionService;
+
+    public GetSupplyHourlyConsumptionController(GetDatadisConsumptionService getDatadisConsumptionService) {
+        this.getDatadisConsumptionService = getDatadisConsumptionService;
+    }
+
+    @GetMapping
+    @Operation(
+            summary = "Retrieves hourly consumption data for a specific supply",
+            description = """
+                    This endpoint retrieves hourly consumption data from Datadis for a specific supply within a given date range.
+
+                    **Authorization Rules:**
+                    - Users with role ADMIN can retrieve consumption data for any supply
+                    - Users with role PARTNER can only retrieve consumption data for their own supplies
+
+                    The consumption data includes:
+                    - Total consumption in kWh
+                    - Surplus energy (energy sent to grid)
+                    - Self-consumption energy
+                    - Obtain method (Real/Estimated)
+
+                    Data is aggregated by hour within the specified date range.
+                    """,
+            tags = ApiTag.SUPPLIES,
+            operationId = "getSupplyHourlyConsumption",
+            security = @SecurityRequirement(name = "bearerToken")
+    )
+    @ApiResponses(value = {
+            @ApiResponse(
+                    responseCode = "200",
+                    description = "Consumption data retrieved successfully",
+                    useReturnTypeSchema = true
+            )
+    })
+    @BadRequestErrorResponse
+    @InternalServerErrorResponse
+    @UnauthorizedErrorResponse
+    @ForbiddenErrorResponse
+    @NotFoundErrorResponse
+    @PreAuthorize("isAuthenticated()")
+    public List<DatadisConsumption> getSupplyHourlyConsumption(
+            @PathVariable("id") UUID id,
+            @RequestParam("startDate") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime startDate,
+            @RequestParam("endDate") @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime endDate) {
+
+        return getDatadisConsumptionService.getHourlyConsumptionBySupply(SupplyId.of(id), startDate, endDate);
+    }
+}

src/main/java/org/lucoenergia/conluz/infrastructure/consumption/datadis/get/GetDatadisConsumptionRepositoryInflux.java

@@ -86,6 +86,37 @@ GROUP BY time(%s), cups
         }
     }
 
+    @Override
+    public List<DatadisConsumption> getHourlyConsumptionsByRangeOfDates(Supply supply, OffsetDateTime startDate, OffsetDateTime endDate) {
+        try (InfluxDB connection = influxDbConnectionManager.getConnection()) {
+
+            Query query = new Query(String.format(
+                    """
+                            SELECT
+                                SUM("consumption_kwh") AS "consumption_kwh",
+                                SUM("surplus_energy_kwh") AS "surplus_energy_kwh",
+                                SUM("self_consumption_energy_kwh") AS "self_consumption_energy_kwh",
+                                LAST("obtain_method") AS "obtain_method"
+                            FROM "%s"
+                            WHERE cups = '%s'
+                                AND time >= '%s'
+                                AND time <= '%s'
+                            GROUP BY time(%s), cups
+                            """,
+                    DatadisConfigEntity.CONSUMPTION_KWH_MEASUREMENT,
+                    supply.getCode(),
+                    dateConverter.convertToString(startDate),
+                    dateConverter.convertToString(endDate),
+                    InfluxDuration.HOURLY));
+
+            QueryResult queryResult = connection.query(query);
+
+            InfluxDBResultMapper resultMapper = new InfluxDBResultMapper();
+            List<DatadisConsumptionPoint> consumptionPoints = resultMapper.toPOJO(queryResult, DatadisConsumptionPoint.class);
+            return mapToConsumption(consumptionPoints);
+        }
+    }
+
     private List<DatadisConsumption> mapToConsumption(List<DatadisConsumptionPoint> consumptionPoints) {
         // Map fields from datadisConsumptionPoint to consumption here
         return consumptionPoints.stream()

src/main/java/org/lucoenergia/conluz/infrastructure/consumption/datadis/get/GetDatadisConsumptionRepositoryRest.java

@@ -119,6 +119,11 @@ public List<DatadisConsumption> getDailyConsumptionsByRangeOfDates(Supply supply
         throw new NotImplementedException("Not yet implemented.");
     }
 
+    @Override
+    public List<DatadisConsumption> getHourlyConsumptionsByRangeOfDates(Supply supply, OffsetDateTime startDate, OffsetDateTime endDate) {
+        throw new NotImplementedException("Not yet implemented.");
+    }
+
     private void validateSupply(Supply supply) {
         if (supply.getDistributorCode() == null || supply.getDistributorCode().isEmpty()) {
             throw new DatadisSupplyConfigurationException("Distributor code is mandatory to get monthly consumption.");

src/main/java/org/lucoenergia/conluz/infrastructure/consumption/datadis/get/GetDatadisConsumptionServiceImpl.java

@@ -62,4 +62,31 @@ public List<DatadisConsumption> getDailyConsumptionBySupply(SupplyId supplyId, O
         // Retrieve consumption data
         return getDatadisConsumptionRepository.getDailyConsumptionsByRangeOfDates(supply, startDate, endDate);
     }
+
+    @Override
+    public List<DatadisConsumption> getHourlyConsumptionBySupply(SupplyId supplyId, OffsetDateTime startDate,
+                                                                 OffsetDateTime endDate) {
+        // Get current authenticated user
+        User currentUser = authService.getCurrentUser()
+                .orElseThrow(() -> new IllegalStateException("User must be authenticated"));
+
+        // Get the supply
+        Optional<Supply> supplyOptional = getSupplyRepository.findById(supplyId);
+        if (supplyOptional.isEmpty()) {
+            throw new SupplyNotFoundException(supplyId);
+        }
+
+        Supply supply = supplyOptional.get();
+
+        // Authorization: ADMIN can access any supply, non-ADMIN can only access their own supplies
+        boolean isAdmin = currentUser.getRole() == Role.ADMIN;
+        boolean isOwner = supply.getUser().getId().equals(currentUser.getId());
+
+        if (!isAdmin && !isOwner) {
+            throw new AccessDeniedException("User does not have permission to access this supply's consumption data");
+        }
+
+        // Retrieve consumption data
+        return getDatadisConsumptionRepository.getHourlyConsumptionsByRangeOfDates(supply, startDate, endDate);
+    }
 }

src/main/java/org/lucoenergia/conluz/infrastructure/shared/db/influxdb/InfluxDuration.java

@@ -5,6 +5,7 @@
  */
 public class InfluxDuration {
 
+    public static final String HOURLY = "1h";
     public static final String DAILY = "1d";
     public static final String MONTHLY = "1mo";
     public static final String YEARLY = "1y";