Commit 238830e9 authored by Nikolaos Kyriakoulis's avatar Nikolaos Kyriakoulis
Browse files

Created metrics endpoints for TMF ServiceOrder related information

parent c6a2420c

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

0 → 100644
+72 −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.common.model.service.ServiceStateType;

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 = "ServiceOrderMetricsApi")

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 = "/tmf-api/metrics/totalServiceOrders", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<Map<String, Integer>> 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 = "/tmf-api/metrics/activeServiceOrders", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<Map<String, Integer>> 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 = "/tmf-api/metrics/serviceOrdersGroupByDay", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<Map<String, Object>> 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 = "/tmf-api/metrics/serviceOrdersGroupByState", method = RequestMethod.GET, produces = "application/json;charset=utf-8")

    ResponseEntity<Map<String, Object>> 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
+140 −0
Original line number Diff line number Diff line 
package org.etsi.osl.tmf.metrics.api;



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.HashMap;

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<Map<String, Integer>> getTotalServiceOrders(ServiceOrderStateType state) {

        try {

            int totalServiceOrders = serviceOrderMetricsRepoService.countTotalServiceOrders(state);

            Map<String, Integer> response = new HashMap<>();

            response.put("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<Map<String, Integer>> getTotalActiveServiceOrders() {

        try {

            int totalActiveServiceOrders = serviceOrderMetricsRepoService.countTotalActiveServiceOrders();

            Map<String, Integer> response = new HashMap<>();

            response.put("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<Map<String, Object>> getServiceOrdersGroupedByDay(OffsetDateTime starttime, OffsetDateTime endtime) {

        try {

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



            // Fill missing days with count 0

            Map<String, Long> 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, 0L));

                cursor = cursor.plusDays(1);

            }



            List<Map<String, Object>> groupByDayList = fullDayMap.entrySet().stream()

                    .map(entry -> {

                        Map<String, Object> dayMap = new HashMap<>();

                        dayMap.put("key", entry.getKey());

                        dayMap.put("count", entry.getValue());

                        return dayMap;

                    })

                    .toList();



            Map<String, Object> aggregations = Map.of("groupByDay", groupByDayList);

            Map<String, Object> serviceOrders = Map.of(

                    "total", fullDayMap.values().stream().mapToLong(Long::longValue).sum(),

                    "aggregations", aggregations

            );



            Map<String, Object> response = Map.of("serviceOrders", serviceOrders);



            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<Map<String, Object>> 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);

            });



            // Build groupByState list

            List<Map<String, Object>> groupByStateList = fullStateMap.entrySet().stream()

                    .map(entry -> {

                        Map<String, Object> map = new HashMap<>();

                        map.put("key", entry.getKey());

                        map.put("count", entry.getValue());

                        return map;

                    })

                    .toList();





            // Wrap in response structure

            Map<String, Object> aggregations = Map.of("groupByState", groupByStateList);

            Map<String, Object> services = Map.of(

                    "total", fullStateMap.values().stream().mapToInt(Integer::intValue).sum(),

                    "aggregations", aggregations

            );



            Map<String, Object> response = Map.of("serviceOrders", 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
+74 −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, Long> getServiceOrdersGroupedByDay(OffsetDateTime starttime, OffsetDateTime endtime) {

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

            starttime = endtime.minusDays(31);

        }



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



        return 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()

                ));







    }



    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.requestedStartDate >= :starttime AND sor.requestedCompletionDate <= :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.