diff --git a/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApi.java b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApi.java new file mode 100644 index 0000000000000000000000000000000000000000..07a9252f2eabe24c1c40a022fbad65a51a8d0662 --- /dev/null +++ b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApi.java @@ -0,0 +1,75 @@ +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 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 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 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 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 + ); +} diff --git a/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApiController.java b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApiController.java new file mode 100644 index 0000000000000000000000000000000000000000..6b0a1bf8efe15abe954d20c65fd20f24a65603e8 --- /dev/null +++ b/src/main/java/org/etsi/osl/tmf/metrics/api/ServiceOrderMetricsApiController.java @@ -0,0 +1,123 @@ +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 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 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 getServiceOrdersGroupedByDay(OffsetDateTime starttime, OffsetDateTime endtime) { + try { + Map orderDatesGroupedByDate = serviceOrderMetricsRepoService.getServiceOrdersGroupedByDay(starttime, endtime); + + // Fill missing days with count 0 + Map 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 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 getServiceOrdersGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) { + try { + Map 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 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 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); + } + } + +} diff --git a/src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceOrderMetricsRepoService.java b/src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceOrderMetricsRepoService.java new file mode 100644 index 0000000000000000000000000000000000000000..9bd49793b0f0c264fe72b1231300313c7a406aa6 --- /dev/null +++ b/src/main/java/org/etsi/osl/tmf/metrics/reposervices/ServiceOrderMetricsRepoService.java @@ -0,0 +1,79 @@ +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 activeStates = List.of( + ServiceOrderStateType.INPROGRESS, + ServiceOrderStateType.COMPLETED + ); + + return serviceOrderRepository.countAllActive(currentDate, activeStates); + } + + public Map getServiceOrdersGroupedByDay(OffsetDateTime starttime, OffsetDateTime endtime) { + if (starttime.plusDays(31).isBefore(endtime)) { + starttime = endtime.minusDays(31); + } + + List orderDates = serviceOrderRepository.getOrderDatesBetweenDates(starttime, endtime); + + // First group by day with count as Long + Map 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 to Map + return grouped.entrySet().stream() + .collect(Collectors.toMap( + Map.Entry::getKey, + e -> e.getValue().intValue() + )); + } + + public Map getServiceOrdersGroupedByState(OffsetDateTime starttime, OffsetDateTime endtime) { + if (starttime.plusDays(31).isBefore(endtime)) { + starttime = endtime.minusDays(31); + } + + List rawResults = serviceOrderRepository.groupByStateBetweenDates(starttime, endtime); + + return rawResults.stream() + .collect(Collectors.toMap( + row -> row[0].toString(), + row -> ((Number) row[1]).intValue() + )); + } + +} diff --git a/src/main/java/org/etsi/osl/tmf/so641/repo/ServiceOrderRepository.java b/src/main/java/org/etsi/osl/tmf/so641/repo/ServiceOrderRepository.java index c717e063b2fd3728703133654adcc4f3a58e6e04..b6ee5c83b42f86826ac670677dbbd7858dfa57d0 100644 --- a/src/main/java/org/etsi/osl/tmf/so641/repo/ServiceOrderRepository.java +++ b/src/main/java/org/etsi/osl/tmf/so641/repo/ServiceOrderRepository.java @@ -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 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 states); + + @Query("SELECT sor.state, COUNT(sor) FROM ServiceOrder sor " + + "WHERE sor.orderDate >= :starttime AND sor.orderDate <= :endtime " + + "GROUP BY sor.state") + List groupByStateBetweenDates(OffsetDateTime starttime, OffsetDateTime endtime); + + @Query("SELECT sor.orderDate FROM ServiceOrder sor " + + "WHERE sor.orderDate >= :starttime AND sor.orderDate <= :endtime") + List getOrderDatesBetweenDates(OffsetDateTime starttime, OffsetDateTime endtime); + } diff --git a/src/test/java/org/etsi/osl/services/api/metrics/ServiceOrderMetricsApiControllerTest.java b/src/test/java/org/etsi/osl/services/api/metrics/ServiceOrderMetricsApiControllerTest.java new file mode 100644 index 0000000000000000000000000000000000000000..757f82cd45d6445b6427d08bf4910743fcd8cf27 --- /dev/null +++ b/src/test/java/org/etsi/osl/services/api/metrics/ServiceOrderMetricsApiControllerTest.java @@ -0,0 +1,254 @@ +package org.etsi.osl.services.api.metrics; + +import com.jayway.jsonpath.JsonPath; +import org.etsi.osl.tmf.JsonUtils; +import org.etsi.osl.tmf.OpenAPISpringBoot; +import org.etsi.osl.tmf.so641.model.*; +import org.etsi.osl.tmf.so641.reposervices.ServiceOrderRepoService; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.http.MediaType; +import org.springframework.security.test.context.support.WithMockUser; +import org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors; +import org.springframework.test.context.ActiveProfiles; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.web.servlet.MockMvc; +import org.springframework.test.web.servlet.request.MockMvcRequestBuilders; +import org.springframework.test.web.servlet.setup.MockMvcBuilders; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.context.WebApplicationContext; + +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; +import java.time.temporal.ChronoUnit; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content; +import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status; + +@RunWith(SpringRunner.class) +@Transactional +@SpringBootTest( + webEnvironment = SpringBootTest.WebEnvironment.MOCK, + classes = OpenAPISpringBoot.class +) +//@AutoConfigureTestDatabase //this automatically uses h2 +@AutoConfigureMockMvc +@ActiveProfiles("testing") +//@TestPropertySource( +// locations = "classpath:application-testing.yml") +public class ServiceOrderMetricsApiControllerTest { + + @Autowired + private MockMvc mvc; + + @Autowired + ServiceOrderRepoService serviceOrderRepoService; + + @Autowired + private WebApplicationContext context; + + @Before + public void setup() throws Exception { + mvc = MockMvcBuilders + .webAppContextSetup(context) + .apply(springSecurity()) + .build(); + } + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testCountTotalServiceOrders() throws Exception { + createServiceOrder(ServiceOrderStateType.INPROGRESS); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/totalServiceOrders" ) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk() ) + .andReturn().getResponse().getContentAsString(); + + int totalServiceOrders = JsonPath.read(response, "$.totalServiceOrders"); + + + assertThat(totalServiceOrders).isEqualTo(serviceOrderRepoService.findAll().size()); + } + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testCountTotalServiceOrdersWithState() throws Exception { + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.ACKNOWLEDGED); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/totalServiceOrders" ) + .param("state", "ACKNOWLEDGED") + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk() ) + .andReturn().getResponse().getContentAsString(); + + int totalServiceOrders = JsonPath.read(response, "$.totalServiceOrders"); + + + List serviceOrdersList = serviceOrderRepoService.findAll(); + int activeServiceOrders = (int) serviceOrdersList.stream().filter(serviceOrder -> serviceOrder.getState() == ServiceOrderStateType.ACKNOWLEDGED).count(); + + assertThat(totalServiceOrders).isEqualTo(activeServiceOrders); + assertThat(activeServiceOrders).isEqualTo(1); + } + + @WithMockUser(username="osadmin", roles = {"ADMIN","USER"}) + @Test + public void testGetTotalActiveServiceOrders() throws Exception { + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.COMPLETED); + createServiceOrder(ServiceOrderStateType.COMPLETED); + createServiceOrder(ServiceOrderStateType.ACKNOWLEDGED); + createServiceOrder(ServiceOrderStateType.REJECTED); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/activeServiceOrders" ) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk() ) + .andReturn().getResponse().getContentAsString(); + + int totalServiceOrders = JsonPath.read(response, "$.activeServiceOrders"); + + assertThat(totalServiceOrders).isEqualTo(4); + } + + @WithMockUser(username = "osadmin", roles = {"ADMIN", "USER"}) + @Test + public void testGetServiceOrdersGroupedByDay() throws Exception { + String startTime = OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT); + + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.ACKNOWLEDGED); + createServiceOrder(ServiceOrderStateType.ACKNOWLEDGED); + createServiceOrder(ServiceOrderStateType.PARTIAL); + + String endTime = OffsetDateTime.now(ZoneOffset.UTC).plusDays(4).format(DateTimeFormatter.ISO_INSTANT); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/serviceOrdersGroupByDay") + .param("starttime", startTime) + .param("endtime", endTime) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + + List> groupByDay = JsonPath.read(response, "$.serviceOrders.aggregations.groupByDay"); + + + OffsetDateTime start = OffsetDateTime.parse(startTime); + OffsetDateTime end = OffsetDateTime.parse(endTime); + + DateTimeFormatter formatter = DateTimeFormatter.ISO_INSTANT; + + Map dayCounts = groupByDay.stream() + .collect(Collectors.toMap( + entry -> (String) entry.get("key"), + entry -> (Integer) entry.get("count") + )); + + int totalDays = (int) ChronoUnit.DAYS.between(start.toLocalDate(), end.toLocalDate()) + 1; + + for (int i = 0; i < totalDays; i++) { + OffsetDateTime day = start.plusDays(i).toLocalDate().atStartOfDay().atOffset(ZoneOffset.UTC); + String dayKey = formatter.format(day.toInstant()); + + if (i == 0) { + // Today: should have all 6 + assertThat(dayCounts.get(dayKey)).isEqualTo(6); + } else { + // Other days: should be 0 + assertThat(dayCounts.get(dayKey)).isEqualTo(0); + } + } + } + + @WithMockUser(username = "osadmin", roles = {"ADMIN", "USER"}) + @Test + public void testGetServiceOrdersGroupedByState() throws Exception { + String startTime = OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ISO_INSTANT); + + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.INPROGRESS); + createServiceOrder(ServiceOrderStateType.ACKNOWLEDGED); + createServiceOrder(ServiceOrderStateType.ACKNOWLEDGED); + createServiceOrder(ServiceOrderStateType.PARTIAL); + + String endTime = OffsetDateTime.now(ZoneOffset.UTC).plusDays(4).format(DateTimeFormatter.ISO_INSTANT); + + String response = mvc.perform(MockMvcRequestBuilders.get("/metrics/serviceOrdersGroupByState") + .param("starttime", startTime) + .param("endtime", endTime) + .contentType(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()) + .andReturn().getResponse().getContentAsString(); + + List> groupByState = JsonPath.read(response, "$.serviceOrders.aggregations.groupByState"); + + // Create a map from key -> count + Map stateCounts = groupByState.stream() + .collect(Collectors.toMap( + entry -> (String) entry.get("key"), + entry -> (Integer) entry.get("count") + )); + + assertThat(stateCounts.get("INPROGRESS")).isEqualTo(3); + assertThat(stateCounts.get("ACKNOWLEDGED")).isEqualTo(2); + assertThat(stateCounts.get("PARTIAL")).isEqualTo(1); + assertThat(stateCounts.get("INITIAL")).isEqualTo(0); + assertThat(stateCounts.get("REJECTED")).isEqualTo(0); + assertThat(stateCounts.get("PENDING")).isEqualTo(0); + assertThat(stateCounts.get("HELD")).isEqualTo(0); + assertThat(stateCounts.get("CANCELLED")).isEqualTo(0); + assertThat(stateCounts.get("COMPLETED")).isEqualTo(0); + assertThat(stateCounts.get("FAILED")).isEqualTo(0); + } + + private void createServiceOrder(ServiceOrderStateType stateType) throws Exception { + + ServiceOrderCreate serviceOrder = new ServiceOrderCreate(); + serviceOrder.setCategory("Test Category"); + serviceOrder.setDescription("A Test Service Order"); + serviceOrder.setRequestedStartDate(OffsetDateTime.now(ZoneOffset.UTC).toString()); + serviceOrder.setRequestedCompletionDate(OffsetDateTime.now(ZoneOffset.UTC).plusDays(3).toString()); + + String response = mvc + .perform(MockMvcRequestBuilders.post("/serviceOrdering/v4/serviceOrder") + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON).content(JsonUtils.toJson(serviceOrder))) + .andExpect(status().isOk()).andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andExpect(status().isOk()).andReturn().getResponse().getContentAsString(); + + ServiceOrder responseSO = JsonUtils.toJsonObj(response, ServiceOrder.class); + + // Update Service Order State + String soId = responseSO.getId(); + + ServiceOrderUpdate servOrderUpd = new ServiceOrderUpdate(); + servOrderUpd.setState(stateType); + + String response2 = mvc.perform(MockMvcRequestBuilders.patch("/serviceOrdering/v4/serviceOrder/" + soId) + .with( SecurityMockMvcRequestPostProcessors.csrf()) + .contentType(MediaType.APPLICATION_JSON) + .content( JsonUtils.toJson( servOrderUpd ) )) + .andExpect(status().isOk() ) + .andExpect(content().contentTypeCompatibleWith(MediaType.APPLICATION_JSON)) + .andReturn().getResponse().getContentAsString(); + + ServiceOrder responsesServiceOrder2 = JsonUtils.toJsonObj(response2, ServiceOrder.class); + assertThat(responsesServiceOrder2.getState().toString()).isEqualTo(stateType.toString()); + } + +}