Commit fa3ee343 authored by Kostis Trantzas's avatar Kostis Trantzas
Browse files

Merge branch '69-create-metrics-endpoints-for-tmf-service-order-related-information' into 'develop' 

starttime and endtime parameters in groupByStateBetweenDates method is...

See merge request !67
parents ffdb9458 7d3d261a

src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApi.java

0 → 100644
+75 −0
Original line number Diff line number Diff line 
package org.etsi.osl.tmf.metrics.api;



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.tags.Tag;

import jakarta.validation.Valid;

import org.etsi.osl.tmf.metrics.ActiveServiceOrders;

import org.etsi.osl.tmf.metrics.ServiceOrdersGroupByDay;

import org.etsi.osl.tmf.metrics.ServiceOrdersGroupByState;

import org.etsi.osl.tmf.metrics.TotalServiceOrders;

import org.etsi.osl.tmf.so641.model.ServiceOrderStateType;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.format.annotation.DateTimeFormat;

import org.springframework.http.ResponseEntity;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;



import java.time.OffsetDateTime;

import java.util.Map;



@Tag(name = "MetricsApi")

public interface ServiceOrderMetricsApi {



    Logger log = LoggerFactory.getLogger(ServiceOrderMetricsApi.class);



    @Operation(summary = "Get total number of service orders", operationId = "getTotalServiceOrders")

    @ApiResponses(value = {

            @ApiResponse(responseCode = "200", description = "Success"),

            @ApiResponse(responseCode = "400", description = "Bad Request"),

            @ApiResponse(responseCode = "500", description = "Internal Server Error")

    })

    @RequestMapping(value = "/metrics/totalServiceOrders", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<TotalServiceOrders> getTotalServiceOrders(

            @Valid @RequestParam(value = "state", required = false) ServiceOrderStateType state

    );





    @Operation(summary = "Get total number of active service orders", operationId = "getTotalActiveServiceOrders")

    @ApiResponses(value = {

            @ApiResponse(responseCode = "200", description = "Success"),

            @ApiResponse(responseCode = "400", description = "Bad Request"),

            @ApiResponse(responseCode = "500", description = "Internal Server Error")

    })

    @RequestMapping(value = "/metrics/activeServiceOrders", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<ActiveServiceOrders> getTotalActiveServiceOrders();





    @Operation(summary = "Get service orders grouped by day", operationId = "getServiceOrdersGroupedByDay")

    @ApiResponses(value = {

            @ApiResponse(responseCode = "200", description = "Success"),

            @ApiResponse(responseCode = "400", description = "Bad Request"),

            @ApiResponse(responseCode = "500", description = "Internal Server Error")

    })

    @RequestMapping(value = "/metrics/serviceOrdersGroupByDay", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<ServiceOrdersGroupByDay> getServiceOrdersGroupedByDay(

            @Valid @RequestParam(value = "starttime", required = true) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime starttime,

            @Valid @RequestParam(value = "endtime", required = true) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime endtime

    );





    @Operation(summary = "Get service orders grouped by state", operationId = "getServiceOrdersGroupedByState")

    @ApiResponses(value = {

            @ApiResponse(responseCode = "200", description = "Success"),

            @ApiResponse(responseCode = "400", description = "Bad Request"),

            @ApiResponse(responseCode = "500", description = "Internal Server Error")

    })

    @RequestMapping(value = "/metrics/serviceOrdersGroupByState", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<ServiceOrdersGroupByState> getServiceOrdersGroupedByState(

            @Valid @RequestParam(value = "starttime", required = true) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime starttime,

            @Valid @RequestParam(value = "endtime", required = true) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) OffsetDateTime endtime

    );

}

src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApiController.java

0 → 100644
+123 −0
Original line number Diff line number Diff line 
package org.etsi.osl.tmf.metrics.api;



import org.etsi.osl.tmf.metrics.*;

import org.etsi.osl.tmf.metrics.reposervices.ServiceOrderMetricsRepoService;

import org.etsi.osl.tmf.so641.model.ServiceOrderStateType;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.HttpStatus;

import org.springframework.http.ResponseEntity;

import org.springframework.stereotype.Controller;



import java.time.OffsetDateTime;

import java.time.temporal.ChronoUnit;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;





@Controller

public class ServiceOrderMetricsApiController implements ServiceOrderMetricsApi {



    private static final Logger log = LoggerFactory.getLogger(ServiceOrderMetricsApiController.class);

    private final ServiceOrderMetricsRepoService serviceOrderMetricsRepoService;



    @Autowired

    public ServiceOrderMetricsApiController(ServiceOrderMetricsRepoService serviceOrderMetricsRepoService) {

        this.serviceOrderMetricsRepoService = serviceOrderMetricsRepoService;

    }



    @Override

    public ResponseEntity<TotalServiceOrders> getTotalServiceOrders(ServiceOrderStateType state) {

        try {

            int totalServiceOrders = serviceOrderMetricsRepoService.countTotalServiceOrders(state);

            TotalServiceOrders response = new TotalServiceOrders(totalServiceOrders);

            return new ResponseEntity<>(response, HttpStatus.OK);

        } catch (Exception e) {

            log.error("Couldn't retrieve total service orders. ", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<ActiveServiceOrders> getTotalActiveServiceOrders() {

        try {

            int totalActiveServiceOrders = serviceOrderMetricsRepoService.countTotalActiveServiceOrders();

            ActiveServiceOrders response = new ActiveServiceOrders(totalActiveServiceOrders);

            return new ResponseEntity<>(response, HttpStatus.OK);

        } catch (Exception e) {

            log.error("Couldn't retrieve total active service orders. ", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<ServiceOrdersGroupByDay> getServiceOrdersGroupedByDay(OffsetDateTime starttime, OffsetDateTime endtime) {

        try {

            Map<String, Integer> orderDatesGroupedByDate = serviceOrderMetricsRepoService.getServiceOrdersGroupedByDay(starttime, endtime);



            // Fill missing days with count 0

            Map<String, Integer> fullDayMap = new LinkedHashMap<>();

            OffsetDateTime cursor = starttime.truncatedTo(ChronoUnit.DAYS);

            OffsetDateTime endDay = endtime.truncatedTo(ChronoUnit.DAYS);

            while (!cursor.isAfter(endDay)) {

                String key = cursor.toInstant().toString();

                fullDayMap.put(key, orderDatesGroupedByDate.getOrDefault(key, 0));

                cursor = cursor.plusDays(1);

            }



            // Convert to model list

            List<ServiceOrdersGroupByDayItem> groupByDayList = fullDayMap.entrySet().stream()

                    .map(entry -> new ServiceOrdersGroupByDayItem(entry.getKey(), entry.getValue()))

                    .toList();



            ServiceOrdersGroupByDayAggregations aggregations = new ServiceOrdersGroupByDayAggregations(groupByDayList);

            int total = fullDayMap.values().stream().mapToInt(Integer::intValue).sum();

            ServiceOrdersGroupByDayParent wrapper = new ServiceOrdersGroupByDayParent(total, aggregations);

            ServiceOrdersGroupByDay response = new ServiceOrdersGroupByDay(wrapper);



            return new ResponseEntity<>(response, HttpStatus.OK);



        } catch (Exception e) {

            log.error("Couldn't retrieve services grouped by state. ", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



    @Override

    public ResponseEntity<ServiceOrdersGroupByState> getServiceOrdersGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) {

        try {

            Map<String, Integer> servicesByState = serviceOrderMetricsRepoService.getServiceOrdersGroupedByState(starttime, endtime);



            // Initialize with all possible states and 0. Ensures that all states are represented, even if not present in the data.

            Map<String, Integer> fullStateMap = new LinkedHashMap<>();

            for (ServiceOrderStateType state : ServiceOrderStateType.values()) {

                fullStateMap.put(state.name(), 0);

            }



            // Overwrite counts with actual data

            servicesByState.forEach((key, value) -> {

                fullStateMap.put(key.toUpperCase(), value);

            });



            // Create aggregation items

            List<ServiceOrdersGroupByStateItem> groupByStateList = fullStateMap.entrySet().stream()

                    .map(entry -> new ServiceOrdersGroupByStateItem(ServiceOrderStateType.valueOf(entry.getKey()), entry.getValue()))

                    .toList();



            // Build response structure using models

            ServiceOrdersGroupByStateAggregations aggregations = new ServiceOrdersGroupByStateAggregations(groupByStateList);

            int total = fullStateMap.values().stream().mapToInt(Integer::intValue).sum();

            ServiceOrdersGroupByStateParent services = new ServiceOrdersGroupByStateParent(total, aggregations);

            ServiceOrdersGroupByState response = new ServiceOrdersGroupByState(services);



            return new ResponseEntity<>(response, HttpStatus.OK);



        } catch (Exception e) {

            log.error("Couldn't retrieve services grouped by state. ", e);

            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);

        }

    }



}

src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceOrderMetricsRepoService.java

0 → 100644
+79 −0
Original line number Diff line number Diff line 
package org.etsi.osl.tmf.metrics.reposervices;



import com.fasterxml.jackson.databind.ObjectMapper;

import org.etsi.osl.tmf.so641.model.ServiceOrderStateType;

import org.etsi.osl.tmf.so641.repo.ServiceOrderRepository;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;



import java.time.OffsetDateTime;

import java.time.temporal.ChronoUnit;

import java.util.List;

import java.util.Map;

import java.util.stream.Collectors;



@Service

public class ServiceOrderMetricsRepoService {



    @Autowired

    ObjectMapper objectMapper;



    @Autowired

    ServiceOrderRepository serviceOrderRepository;



    public int countTotalServiceOrders(ServiceOrderStateType state) {

        if (state == null) {

            return serviceOrderRepository.countAll();

        } else {

            return serviceOrderRepository.countByState(state);

        }

    }



    public int countTotalActiveServiceOrders() {

        OffsetDateTime currentDate = OffsetDateTime.now();

        List<ServiceOrderStateType> activeStates = List.of(

                ServiceOrderStateType.INPROGRESS,

                ServiceOrderStateType.COMPLETED

        );



        return serviceOrderRepository.countAllActive(currentDate, activeStates);

    }



    public Map<String, Integer> getServiceOrdersGroupedByDay(OffsetDateTime starttime, OffsetDateTime endtime) {

        if (starttime.plusDays(31).isBefore(endtime)) {

            starttime = endtime.minusDays(31);

        }



        List<OffsetDateTime> orderDates = serviceOrderRepository.getOrderDatesBetweenDates(starttime, endtime);



        // First group by day with count as Long

        Map<String, Long> grouped = orderDates.stream()

                .map(dt -> dt.truncatedTo(ChronoUnit.DAYS))  // Remove time portion

                .collect(Collectors.groupingBy(

                        dt -> dt.toInstant().toString(),      // Format as ISO string (Z)

                        Collectors.counting()

                ));



        // Convert Map<String, Long> to Map<String, Integer>

        return grouped.entrySet().stream()

                .collect(Collectors.toMap(

                        Map.Entry::getKey,

                        e -> e.getValue().intValue()

                ));

    }



    public Map<String, Integer> getServiceOrdersGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) {

        if (starttime.plusDays(31).isBefore(endtime)) {

            starttime = endtime.minusDays(31);

        }



        List<Object[]> rawResults = serviceOrderRepository.groupByStateBetweenDates(starttime, endtime);



        return rawResults.stream()

                .collect(Collectors.toMap(

                        row -> row[0].toString(),

                        row -> ((Number) row[1]).intValue()

                ));

    }



}

src/main/java/org/etsi/osl/tmf/so641/repo/ServiceOrderRepository.java

+24 −0
Original line number Diff line number Diff line
@@ -19,6 +19,7 @@ 
 */

package org.etsi.osl.tmf.so641.repo;



import java.time.OffsetDateTime;

import java.util.List;

import java.util.Optional;

import org.etsi.osl.tmf.common.model.UserPartRoleType;
@@ -51,4 +52,27 @@ public interface ServiceOrderRepository extends JpaRepository<ServiceOrder, Long 
			+ "WHERE sor.uuid = ?1 "

			+ "ORDER BY an.date ASC")	

	Optional<ServiceOrder> findNotesOfServOrder(String id);





	// Methods for metrics



	@Query("SELECT COUNT(sor) FROM ServiceOrder sor")

	int countAll();



	int countByState(ServiceOrderStateType state);



	@Query("SELECT COUNT(sor) FROM ServiceOrder sor "

			+ "WHERE sor.state IN :states "

			+ "AND sor.requestedStartDate < :currentDate AND sor.requestedCompletionDate > :currentDate")

	int countAllActive(OffsetDateTime currentDate, List<ServiceOrderStateType> states);



	@Query("SELECT sor.state, COUNT(sor) FROM ServiceOrder sor "

			+ "WHERE sor.orderDate >= :starttime AND sor.orderDate <= :endtime "

			+ "GROUP BY sor.state")

	List<Object[]> groupByStateBetweenDates(OffsetDateTime starttime, OffsetDateTime endtime);



	@Query("SELECT sor.orderDate FROM ServiceOrder sor " +

			"WHERE sor.orderDate >= :starttime AND sor.orderDate <= :endtime")

	List<OffsetDateTime> getOrderDatesBetweenDates(OffsetDateTime starttime, OffsetDateTime endtime);



}

src/test/java/org/etsi/osl/services/api/metrics/ServiceOrderMetricsApiControllerTest.java

0 → 100644
+254 −0

File added.

Preview size limit exceeded, changes collapsed.