<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-starter-validation</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-configuration-processor</artifactId>
+ <optional>true</optional>
+ </dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.boot.web.servlet.MultipartConfigFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import jakarta.servlet.MultipartConfigElement;
@SpringBootApplication
-@EnableAutoConfiguration(exclude={JpaRepositoriesAutoConfiguration.class})
+@EnableConfigurationProperties
@ComponentScan(basePackages = "org.onap.usecaseui.server")
+@EnableAutoConfiguration(exclude={JpaRepositoriesAutoConfiguration.class})
public class UuiServerApplication {
public static DmaapSubscriber dmaapSubscriber;
public void setDatastore(DmaapSubscriber dmaapSubscriber) {
UuiServerApplication.dmaapSubscriber = dmaapSubscriber;
}
-
+
@Bean
public RestTemplate getRestTemplate(){
return new RestTemplate();
import java.io.IOException;
import org.onap.usecaseui.server.service.lcm.domain.aai.AAIService;
+import org.onap.usecaseui.server.service.slicingdomain.aai.AAISliceService;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AAIClientConfig {
- @Value("${client.aai.baseUrl}")
+ @Value("${uui-server.client.aai.baseUrl}")
String baseUrl;
- @Value("${client.aai.username}")
+ @Value("${uui-server.client.aai.username}")
String username;
- @Value("${client.aai.password}")
+ @Value("${uui-server.client.aai.password}")
String password;
@Bean
AAIService aaiService(Retrofit retrofit) {
return retrofit.create(AAIService.class);
}
+
+ @Bean
+ AAISliceService aaiSliceService(Retrofit retrofit) {
+ return retrofit.create(AAISliceService.class);
+ }
}
--- /dev/null
+/**
+ * Copyright 2025 Deutsche Telekom.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.usecaseui.server.config;
+
+import java.io.IOException;
+
+import org.onap.usecaseui.server.service.lcm.domain.so.SOService;
+import org.onap.usecaseui.server.service.slicingdomain.so.SOSliceService;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.HttpHeaders;
+
+import okhttp3.Credentials;
+import okhttp3.Interceptor;
+import okhttp3.OkHttpClient;
+import okhttp3.Request;
+import retrofit2.Retrofit;
+import retrofit2.converter.jackson.JacksonConverterFactory;
+
+@Configuration
+public class SOClientConfig {
+
+ @Value("${uui-server.client.so.baseUrl}")
+ String baseUrl;
+ @Value("${uui-server.client.so.username}")
+ String username;
+ @Value("${uui-server.client.so.password}")
+ String password;
+
+ OkHttpClient okHttpClient() {
+ return new OkHttpClient().newBuilder().addInterceptor(new Interceptor() {
+ @Override
+ public okhttp3.Response intercept(Chain chain) throws IOException {
+ Request originalRequest = chain.request();
+ Request.Builder builder = originalRequest.newBuilder()
+ .header("Authorization", Credentials.basic(username, password))
+ .header(HttpHeaders.ACCEPT, "application/json")
+ .header("X-TransactionId", "9999")
+ .header("X-FromAppId", "onap-cli");
+ Request newRequest = builder.build();
+ return chain.proceed(newRequest);
+ }
+ }).build();
+ }
+
+ Retrofit retrofit() {
+ return new Retrofit.Builder()
+ .baseUrl(baseUrl)
+ .addConverterFactory(JacksonConverterFactory.create())
+ .client(okHttpClient())
+ .build();
+ }
+
+ @Bean
+ SOService soService() {
+ return retrofit().create(SOService.class);
+ }
+
+ @Bean
+ SOSliceService soSliceService() {
+ return retrofit().create(SOSliceService.class);
+ }
+}
--- /dev/null
+package org.onap.usecaseui.server.service.csmf.config;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+
+import lombok.Data;
+
+@Data
+@Configuration
+@ConfigurationProperties(prefix = "uui-server.slicing")
+public class SlicingProperties {
+ String serviceInvariantUuid;
+ String serviceUuid;
+ String globalSubscriberId;
+ String serviceType;
+}
import com.google.gson.reflect.TypeToken;
import java.io.File;
import java.io.FileInputStream;
+import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Type;
import java.util.List;
import java.util.Properties;
import java.util.stream.Collectors;
-import jakarta.annotation.Resource;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
import okhttp3.MediaType;
import okhttp3.RequestBody;
import org.onap.usecaseui.server.bean.ServiceInstanceOperations;
import org.onap.usecaseui.server.constant.nsmf.NsmfCodeConstant;
import org.onap.usecaseui.server.constant.nsmf.NsmfParamConstant;
import org.onap.usecaseui.server.service.csmf.SlicingService;
+import org.onap.usecaseui.server.service.csmf.config.SlicingProperties;
import org.onap.usecaseui.server.service.lcm.ServiceLcmService;
import org.onap.usecaseui.server.service.slicingdomain.aai.AAISliceService;
import org.onap.usecaseui.server.service.slicingdomain.aai.bean.AAIServiceInstance;
import org.onap.usecaseui.server.service.slicingdomain.so.SOSliceService;
import org.onap.usecaseui.server.service.slicingdomain.so.bean.SOOperation;
-import org.onap.usecaseui.server.util.RestfulServices;
import org.onap.usecaseui.server.util.nsmf.NsmfCommonUtil;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Service;
import retrofit2.Response;
+@Slf4j
+@RequiredArgsConstructor
@Service("SlicingService")
-@org.springframework.context.annotation.Configuration
-@EnableAspectJAutoProxy
public class SlicingServiceImpl implements SlicingService {
- private final static Logger logger = LoggerFactory.getLogger(SlicingServiceImpl.class);
-
- @Resource(name = "ServiceLcmService")
- private ServiceLcmService serviceLcmService;
-
- private AAISliceService aaiSliceService;
-
- private SOSliceService soSliceService;
-
- public SlicingServiceImpl() {
- this(RestfulServices.create(AAISliceService.class), RestfulServices.create(SOSliceService.class));
- }
-
- public SlicingServiceImpl(AAISliceService aaiSliceService, SOSliceService soSliceService) {
- this.aaiSliceService = aaiSliceService;
- this.soSliceService = soSliceService;
- }
+ private static final Gson gson = new Gson();
+ private final ServiceLcmService serviceLcmService;
+ private final AAISliceService aaiSliceService;
+ private final SOSliceService soSliceService;
+ private final SlicingProperties slicingProperties;
@Override
public ServiceResult createSlicingService(SlicingOrder slicingOrder) {
- ServiceCreateResult createResult = new ServiceCreateResult();
String resultCode;
String resultMsg;
- Gson gson = new Gson();
+
ResultHeader resultHeader = new ResultHeader();
+ ServiceCreateResult createResult = new ServiceCreateResult();
try {
// request bean for create slicing service
- CreationRequestInputs requestInputs = new CreationRequestInputs();
- requestInputs.setExpDataRateDL(slicingOrder.getSlicing_order_info().getExpDataRateDL());
- requestInputs.setExpDataRateUL(slicingOrder.getSlicing_order_info().getExpDataRateUL());
- requestInputs.setLatency(slicingOrder.getSlicing_order_info().getLatency());
- requestInputs.setMaxNumberofUEs(slicingOrder.getSlicing_order_info().getMaxNumberofUEs());
- requestInputs.setUEMobilityLevel(slicingOrder.getSlicing_order_info().getUEMobilityLevel());
- requestInputs.setResourceSharingLevel(slicingOrder.getSlicing_order_info().getResourceSharingLevel());
- requestInputs.setCoverageAreaList(slicingOrder.getSlicing_order_info().getCoverageArea());
- //use default value
- requestInputs.setUseInterval("20");
- CreationParameters parameters = new CreationParameters();
- parameters.setRequestInputs(requestInputs);
- CreationService creationService = new CreationService();
- creationService.setName(slicingOrder.getSlicing_order_info().getName());
- creationService.setDescription(CommonConstant.BLANK);
- String slicingPath = System.getProperty("user.dir") + File.separator + "config" + File.separator + "slicing.properties";
- InputStream inputStream = new FileInputStream(new File(slicingPath));
- Properties environment = new Properties();
- environment.load(inputStream);
- String serviceInvariantUuid = environment.getProperty("slicing.serviceInvariantUuid");
- creationService.setServiceInvariantUuid(serviceInvariantUuid);
- String serviceUuid = environment.getProperty("slicing.serviceUuid");
- creationService.setServiceUuid(serviceUuid);
- logger.info("serviceInvariantUuid is {}, serviceUuid is {}.", serviceInvariantUuid, serviceUuid);
-
- creationService.setGlobalSubscriberId(environment.getProperty("slicing.globalSubscriberId"));
- creationService.setServiceType(environment.getProperty("slicing.serviceType"));
- creationService.setParameters(parameters);
+ CreationRequestInputs requestInputs = mapCreationRequest(slicingOrder);
+ CreationService creationService = buildCreationService(slicingOrder, requestInputs);
CreationRequest creationRequest = new CreationRequest();
creationRequest.setService(creationService);
String jsonstr = gson.toJson(creationRequest);
- logger.info("createSlicingService:creationRequest request is:{}", jsonstr);
+ log.info("createSlicingService:creationRequest request is:{}", jsonstr);
RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), jsonstr.toString());
Response<CreateResponse> updateResponse = soSliceService
.submitOrders(requestBody).execute();
if (updateResponse.isSuccessful()) {
CreateResponse createResponse = updateResponse.body();
- logger.info("createSlicingService: submitOrders reponse is:{}",
+ log.info("createSlicingService: submitOrders reponse is:{}",
gson.toJson(createResponse).toString());
// set create operation result
resultMsg = "5G slicing order created normally.";
resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
} else {
- logger.error(String
+ log.error(String
.format("createSlicingService: Can not submitOrders [code={}, message={}]", updateResponse.code(),
updateResponse.message()));
resultMsg = "5G slicing order created failed.";
// set error message
resultMsg = "5G slicing order created failed. Unknown exception occurred!";
resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
- logger.error(e.getMessage());
+ log.error(e.getMessage());
}
- logger.info(resultMsg);
- logger.info("createSlicingService: 5G slicing order creation has been finished.");
+ log.info(resultMsg);
+ log.info("createSlicingService: 5G slicing order creation has been finished.");
resultHeader.setResult_message(resultMsg);
ServiceResult serviceResult = new ServiceResult(resultHeader, createResult);
return serviceResult;
}
+ private CreationRequestInputs mapCreationRequest(SlicingOrder slicingOrder) {
+ CreationRequestInputs requestInputs = new CreationRequestInputs();
+ requestInputs.setExpDataRateDL(slicingOrder.getSlicing_order_info().getExpDataRateDL());
+ requestInputs.setExpDataRateUL(slicingOrder.getSlicing_order_info().getExpDataRateUL());
+ requestInputs.setLatency(slicingOrder.getSlicing_order_info().getLatency());
+ requestInputs.setMaxNumberofUEs(slicingOrder.getSlicing_order_info().getMaxNumberofUEs());
+ requestInputs.setUEMobilityLevel(slicingOrder.getSlicing_order_info().getUEMobilityLevel());
+ requestInputs.setResourceSharingLevel(slicingOrder.getSlicing_order_info().getResourceSharingLevel());
+ requestInputs.setCoverageAreaList(slicingOrder.getSlicing_order_info().getCoverageArea());
+ //use default value
+ requestInputs.setUseInterval("20");
+ return requestInputs;
+ }
+
+ private CreationService buildCreationService(SlicingOrder slicingOrder, CreationRequestInputs requestInputs)
+ throws FileNotFoundException, IOException {
+ CreationParameters parameters = new CreationParameters();
+ parameters.setRequestInputs(requestInputs);
+ CreationService creationService = new CreationService();
+ creationService.setName(slicingOrder.getSlicing_order_info().getName());
+ creationService.setDescription(CommonConstant.BLANK);
+
+ String slicingPath = System.getProperty("user.dir") + File.separator + "config" + File.separator + "slicing.properties";
+ try {
+ // kept for compatibility reasons
+ InputStream inputStream = new FileInputStream(new File(slicingPath));
+ setEnvironmentProperties(creationService, inputStream);
+ } catch (FileNotFoundException e) {
+ addConfigurationProperties(creationService);
+ }
+
+ creationService.setParameters(parameters);
+ return creationService;
+ }
+
+ private void addConfigurationProperties(CreationService creationService) {
+ creationService.setServiceInvariantUuid(slicingProperties.getServiceInvariantUuid());
+ creationService.setServiceUuid(slicingProperties.getServiceUuid());
+ creationService.setGlobalSubscriberId(slicingProperties.getGlobalSubscriberId());
+ creationService.setServiceType(slicingProperties.getServiceType());
+ }
+
+ private void setEnvironmentProperties(CreationService creationService, InputStream inputStream)
+ throws IOException {
+ Properties environment = new Properties();
+ environment.load(inputStream);
+ String serviceInvariantUuid = environment.getProperty("slicing.serviceInvariantUuid");
+ creationService.setServiceInvariantUuid(serviceInvariantUuid);
+ String serviceUuid = environment.getProperty("slicing.serviceUuid");
+ creationService.setServiceUuid(serviceUuid);
+ log.info("serviceInvariantUuid is {}, serviceUuid is {}.", serviceInvariantUuid, serviceUuid);
+
+ creationService.setGlobalSubscriberId(environment.getProperty("slicing.globalSubscriberId"));
+ creationService.setServiceType(environment.getProperty("slicing.serviceType"));
+ }
+
@Override
public ServiceResult querySlicingOrderList(String status, String pageNo, String pageSize) {
Response<JSONObject> response = this.aaiSliceService
.listOrders(NsmfParamConstant.CUSTOM_5G, NsmfParamConstant.SERVICE_TYPE_5G).execute();
if (response.isSuccessful()) {
- logger.info("querySlicingOrderList: listService reponse is:{}", response.body());
+ log.info("querySlicingOrderList: listService reponse is:{}", response.body());
Type type = new TypeToken<List<AAIServiceInstance>>() {
}.getType();
resultMsg = "5G slicing order query result.";
resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
} else {
- logger.error(String.format("querySlicingOrderList: Can not get listOrders[code={}, message={}]",
+ log.error(String.format("querySlicingOrderList: Can not get listOrders[code={}, message={}]",
response.code(),
response.message()));
resultMsg = "\"5G slicing order query failed!";
Exception e) {
resultMsg = "5G slicing order query failed. Unknown exception occurred!";
resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
- logger.error(e.getMessage());
+ log.error(e.getMessage());
}
// Filter by status and paginate
// return API result for calling [Query Slicing Order List]
OrderList responseOrderList = new OrderList(orderList.size(), pagedOrderList.getPagedList());
addProgressToOrder(responseOrderList);
- logger.info(resultMsg);
- logger.info("querySlicingOrderList: 5G slicing order query has been finished.");
+ log.info(resultMsg);
+ log.info("querySlicingOrderList: 5G slicing order query has been finished.");
resultHeader.setResult_message(resultMsg);
serviceResult.setResult_header(resultHeader);
serviceResult.setResult_body(responseOrderList);
OrderInfo order = new OrderInfo();
order.setOrder_id(object.getString("service-instance-id"));
order.setOrder_name(object.getString("service-instance-name"));
- order.setOrder_creation_time(NsmfCommonUtil.timestamp2Time(object.getString("created-at")));
+ String createdAt = object.getString("created-at");
+ // do not fail when createdAt is null
+ if(createdAt != null) {
+ String timestamp = NsmfCommonUtil.timestamp2Time(createdAt);
+ order.setOrder_creation_time(timestamp);
+ }
order.setOrder_status(object.getString("service-type"));
order.setService_snssai(object.getString("environment-context"));
order.setOrder_status(object.getString("orchestration-status"));
public void addProgressToOrder(OrderList responseOrderList) {
if (responseOrderList.getSlicing_order_list() == null
|| responseOrderList.getSlicing_order_list().size() == 0) {
- logger.error(
+ log.error(
"addProgressToOrder: responseOrderList.getSlicing_order_list() is null or responseOrderList.getSlicing_order_list() size is 0.");
return;
}
ServiceInstanceOperations serviceInstanceOperations = serviceLcmService
.getServiceInstanceOperationById(businessId);
if (null == serviceInstanceOperations || serviceInstanceOperations.getOperationId() == null) {
- logger.error(
+ log.error(
"addProgressToOrder: null == serviceInstanceOperations for businessId:{}.",
businessId);
continue;
if (response.isSuccessful()) {
SOOperation soOperation = response.body();
Gson gson = new Gson();
- logger.info("addProgressToOrder: queryOperationProgress reponse is:{}",
+ log.info("addProgressToOrder: queryOperationProgress reponse is:{}",
gson.toJson(soOperation).toString());
if (soOperation == null || soOperation.getOperation() == null) {
- logger.error("addProgressToOrder: soOperation is null or getOperation() is null for businessId {}!", businessId);
+ log.error("addProgressToOrder: soOperation is null or getOperation() is null for businessId {}!", businessId);
continue;
}
String operationResult = soOperation.getOperation().getResult();
String operationType = soOperation.getOperation().getOperation();
int progress = soOperation.getOperation().getProgress();
- logger.info("addProgressToOrder: operationResult is:{}, operationType is {}, progress is {}",
+ log.info("addProgressToOrder: operationResult is:{}, operationType is {}, progress is {}",
operationResult, operationType, progress);
if (operationResult.equals(NsmfCodeConstant.OPERATION_ERROR_STATUS)) {
- logger.error("addProgressToOrder: progress is ok, but operationResult is error for businessId {}!", businessId);
+ log.error("addProgressToOrder: progress is ok, but operationResult is error for businessId {}!", businessId);
continue;
}
orderInfo.setLast_operation_type(operationType);
orderInfo.setLast_operation_progress(String.valueOf(progress));
}
} catch (IOException e) {
- logger.error(e.getMessage());
- logger.error("addProgressToOrder: catch an IOException for businessId {}!", businessId);
+ log.error(e.getMessage());
+ log.error("addProgressToOrder: catch an IOException for businessId {}!", businessId);
continue;
}
}
public interface SOService {
- @Headers({
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@POST("/api/so-serviceInstances/v3")
Call<ServiceOperation> instantiateService(@Body RequestBody body);
- @Headers({
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@GET("/api/so-serviceInstances/v3/{serviceId}/operations/{operationId}")
Call<OperationProgressInformation> queryOperationProgress(@Path("serviceId") String serviceId, @Path("operationId") String operationId);
- @Headers({
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
// @DELETE("/ecomp/mso/infra/e2eServiceInstances/v3/{serviceId}")
@HTTP(method="DELETE", path="/api/so-serviceInstances/v3/{serviceId}", hasBody = true)
Call<DeleteOperationRsp> terminateService(@Path("serviceId") String serviceId, @Body RequestBody body);
-
- @Headers({
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
+
@POST("/api/so-serviceInstances/v3/{serviceId}/scale")
Call<SaveOrUpdateOperationRsp> scaleService(@Path("serviceId") String serviceId, @Body RequestBody body);
-
- @Headers({
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
+
@PUT("/api/so-serviceInstances/v3/{serviceId}")
Call<SaveOrUpdateOperationRsp> updateService(@Path("serviceId") String serviceId, @Body RequestBody body);
- @Headers({
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
- //@POST("/onap/so/infra/e2eServiceInstances/v3")
@POST("/api/so-serviceInstances/v5")
Call<ServiceOperation> instantiateSOTNService(@Body E2EServiceInstanceRequest body);
}
import com.google.common.base.Throwables;
import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
import org.hibernate.query.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.onap.usecaseui.server.service.lcm.domain.so.bean.ServiceOperation;
import org.onap.usecaseui.server.service.lcm.domain.so.exceptions.SOException;
import org.onap.usecaseui.server.util.DateUtils;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import okhttp3.RequestBody;
import retrofit2.Response;
-@Service("ServiceLcmService")
+@Slf4j
@Transactional
+@Service("ServiceLcmService")
+@RequiredArgsConstructor
public class DefaultServiceLcmService implements ServiceLcmService {
- private static final Logger logger = LoggerFactory.getLogger(DefaultServiceLcmService.class);
-
- @Autowired
- private EntityManagerFactory entityManagerFactory;
+ private final EntityManagerFactory entityManagerFactory;
+ private final SOService soService;
public Session getSession() {
return entityManagerFactory.unwrap(SessionFactory.class).getCurrentSession();}
- private SOService soService;
-
- public DefaultServiceLcmService() {
- this(create(SOService.class));
- }
-
- public DefaultServiceLcmService(SOService soService) {
- this.soService = soService;
- }
-
@Override
public ServiceOperation instantiateService(HttpServletRequest request) {
try {
- logger.info("so instantiate is starting");
+ log.info("so instantiate is starting");
RequestBody requestBody = extractBody(request);
Response<ServiceOperation> response = soService.instantiateService(requestBody).execute();
- logger.info("so instantiate has finished");
+ log.info("so instantiate has finished");
if (response.isSuccessful()) {
return response.body();
} else {
- logger.error(String.format("Can not instantiate service[code=%s, message=%s]", response.code(),
+ log.error(String.format("Can not instantiate service[code=%s, message=%s]", response.code(),
response.message()));
throw new SOException("SO instantiate service failed!");
}
if (response.isSuccessful()) {
return response.body();
} else {
- logger.error(String.format("Can not query operation process[code=%s, message=%s]", response.code(),
+ log.error(String.format("Can not query operation process[code=%s, message=%s]", response.code(),
response.message()));
throw new SOException("SO query operation process failed!");
}
@Override
public DeleteOperationRsp terminateService(String serviceId, HttpServletRequest request) {
try {
- logger.info("so terminate is starting");
+ log.info("so terminate is starting");
RequestBody requestBody = extractBody(request);
Response<DeleteOperationRsp> response = soService.terminateService(serviceId, requestBody).execute();
- logger.info("so terminate has finished");
+ log.info("so terminate has finished");
if (response.isSuccessful()) {
return response.body();
} else {
- logger.error(String.format("Can not terminate service[code=%s, message=%s]", response.code(),
+ log.error(String.format("Can not terminate service[code=%s, message=%s]", response.code(),
response.message()));
throw new SOException("SO terminate service failed!");
}
@Override
public SaveOrUpdateOperationRsp scaleService(String serviceId, HttpServletRequest request) {
try {
- logger.info("so scale is finished");
+ log.info("so scale is finished");
RequestBody requestBody = extractBody(request);
Response<SaveOrUpdateOperationRsp> response = soService.scaleService(serviceId, requestBody).execute();
- logger.info("so scale has finished");
+ log.info("so scale has finished");
if (response.isSuccessful()) {
- logger.info("scaleService response content is :" + response.body().toString());
+ log.info("scaleService response content is :" + response.body().toString());
return response.body();
} else {
- logger.error(String.format("Can not scaleService service[code=%s, message=%s]", response.code(),
+ log.error(String.format("Can not scaleService service[code=%s, message=%s]", response.code(),
response.message()));
throw new SOException("SO terminate service failed!");
}
@Override
public SaveOrUpdateOperationRsp updateService(String serviceId, HttpServletRequest request) {
try {
- logger.info("so update is starting");
+ log.info("so update is starting");
RequestBody requestBody = extractBody(request);
Response<SaveOrUpdateOperationRsp> response = soService.updateService(serviceId, requestBody).execute();
- logger.info("so update has finished");
+ log.info("so update has finished");
if (response.isSuccessful()) {
return response.body();
} else {
- logger.error(String.format("Can not updateService service[code=%s, message=%s]", response.code(),
+ log.error(String.format("Can not updateService service[code=%s, message=%s]", response.code(),
response.message()));
throw new SOException("SO terminate service failed!");
}
Session session = getSession();
try {
if (null == serviceBean) {
- logger.error("DefaultServiceLcmService saveOrUpdateServiceBean serviceBean is null!");
+ log.error("DefaultServiceLcmService saveOrUpdateServiceBean serviceBean is null!");
}
session.saveOrUpdate(serviceBean);
session.flush();
} catch (Exception e) {
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceBean. Details:"
+ e.getMessage());
}
q.executeUpdate();
session.flush();
} catch (Exception e) {
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusById.Detail."
+ e.getMessage());
}
serviceBean = list.get(0);
}
} catch (Exception e) {
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService getServiceBeanByServiceInStanceId.Detail."
+ e.getMessage());
serviceBean = new ServiceBean();;
session.flush();
} catch (Exception e) {
list = new ArrayList<>();
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusByIdDetail."
+ e.getMessage());
}
Session session = getSession();
try {
if (null == serviceOperation) {
- logger.error("DefaultServiceLcmService saveOrUpdateServiceBean serviceOperation is null!");
+ log.error("DefaultServiceLcmService saveOrUpdateServiceBean serviceOperation is null!");
}
session.saveOrUpdate(serviceOperation);
session.flush();
} catch (Exception e) {
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceInstanceOperation. Details:"
+ Throwables.getStackTraceAsString(e));
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService saveOrUpdateServiceInstanceOperation. Details:"
+ e.getMessage());
}
session.flush();
} catch (Exception e) {
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService updateServiceInstanceOperation.Detail."
+ e.getMessage());
}
session.flush();
} catch (Exception e) {
- logger.error("exception occurred while performing DefaultServiceLcmService getServiceInstanceOperationById."
+ log.error("exception occurred while performing DefaultServiceLcmService getServiceInstanceOperationById."
+ e.getMessage());
}
return serviceOperation;
session.flush();
} catch (Exception e) {
list = new ArrayList<>();
- logger.error(
+ log.error(
"exception occurred while performing DefaultServiceLcmService updateServiceInstanceStatusByIdDetail."
+ e.getMessage());
}
public interface AAISliceService {
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=service-profile")
Call<JSONObject> listService(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType);
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
+
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=service-profile")
Call<JSONObject> listServiceByStatus(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Query("orchestration-status") String orchestrationStatus);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}")
Call<JSONObject> listServiceById(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Path("service-instance-id") String businessId);
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=nsi")
Call<JSONObject> listServiceNSI(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=nsi")
Call<JSONObject> listServiceNSIByStatus(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Query("orchestration-status") String orchestrationStatus);
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
+
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=nssi")
Call<JSONObject> listServiceNSSI(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType);
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
+
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=nssi")
Call<JSONObject> listServiceNSSIByStatus(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Query("orchestration-status") String orchestrationStatus);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=nssi")
Call<JSONObject> listServiceNSSIByEnv(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Query("environment-context") String environmentContext);
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v19/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}/service-profiles")
Call<JSONObject> getServiceProfiles(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Path("service-instance-id") String serviceInstanceId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}/allotted-resources")
Call<JSONObject> queryAllottedResources(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Path("service-instance-id") String serviceInstanceId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}")
Call<JSONObject> querySerAndSubInsByNSI(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Path("service-instance-id") String serviceInstanceId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}")
Call<JSONObject> queryNSIByNSSI(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Path("service-instance-id") String serviceInstanceId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}")
Call<JSONObject> queryOrderByService(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Path("service-instance-id") String serviceInstanceId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances/service-instance/{service-instance-id}")
Call<JSONObject> queryOrderByOrderId(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType,@Path("service-instance-id") String serviceInstanceId);
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-sdc/v13/models/model/{model-invariant-id}/model-vers/model-ver/{model-version-id}")
Call<AAIServiceNST> queryServiceNST(@Path("model-invariant-id") String modelInvariantIid,
@Path("model-version-id") String modelVersionId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v13/customers/customer/{global-customer-id}/service-subscriptions/service-subscription/{service-type}/service-instances?service-role=communication-service")
Call<JSONObject> listOrders(@Path("global-customer-id") String globalCustomerId,@Path("service-type") String serviceType);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-network/v21/logical-links")
Call<ConnectionLinkList> getConnectionLinks();
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-network/v21/network-routes/network-route/{route-id}")
Call<EndPointInfoList> getEndpointByLinkName(@Path("route-id") String linkName);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-network/v21/network-routes/network-route/{route-id}")
Call<EndPointInfoList> getEndpointByLinkName2(@Path("route-id") String linkName2);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v21/customers/customer/5GCustomer/service-subscriptions/service-subscription/5G/service-instances/service-instance/{service-instance-id}/allotted-resources/allotted-resource/{allotted-resource-id}")
Call<ConnectionLink> getAllottedResource(@Path("service-instance-id") String serviceInstancesId,@Path("allotted-resource-id") String allottedResourceId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v21/customers/customer/5GCustomer/service-subscriptions/service-subscription/5G/service-instances/service-instance/{service-instance-id}")
Call<ConnectionLink> getServiceInstance(@Path("service-instance-id") String serviceInstancesId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v21/customers/customer/5GCustomer/service-subscriptions/service-subscription/5G/service-instances/service-instance/{service-instance-id}")
Call<NetworkInfo> getServiceNetworkInstance(@Path("service-instance-id") String serviceInstancesId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-network/v21/network-policies/network-policy/{network-policy-id}")
Call<NetworkPolicy> getNetworkPolicy(@Path("network-policy-id")String relationshipValue);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: MSO",
- "Authorization: Basic QUFJOkFBSQ==",
- "Accept: application/json"
- })
@GET("/api/aai-business/v21/customers/customer/5GCustomer/service-subscriptions/service-subscription/5G/service-instances/service-instance/{service-instance-id}/slice-profiles")
Call<SliceProfileList> getSliceProfiles(@Path("service-instance-id") String serviceInstancesId);
import retrofit2.http.Body;
import retrofit2.http.GET;
import retrofit2.http.HTTP;
-import retrofit2.http.Headers;
import retrofit2.http.POST;
import retrofit2.http.PUT;
import retrofit2.http.Path;
public interface SOSliceService {
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@GET("/api/so-serviceInstances/v3/{serviceId}/operations/{operationId}")
Call<SOOperation> queryOperationProgress(@Path("serviceId") String serviceId,
@Path("operationId") String operationId);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@POST("/api/so-serviceInstances/v3/{serviceInstanceId}/activate")
Call<ActivateService> activeService(@Path("serviceInstanceId") String serviceInstanceId, @Body RequestBody body);
- @Headers({ "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==", "Accept: application/json" })
@POST("/api/so-serviceInstances/v3/{serviceInstanceId}/deactivate")
Call<ActivateService> deactiveService(@Path("serviceInstanceId") String serviceInstanceId, @Body RequestBody body);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
-
@HTTP(method = "DELETE",path = "/api/so-serviceInstances/v3/{serviceInstanceId}",hasBody = true)
Call<ActivateService> terminateService(@Path("serviceInstanceId") String serviceInstanceId, @Body RequestBody body);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@GET("/api/so-orchestrationTasks/v4")
Call<JSONArray> listTask();
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
+
@GET("/api/so-orchestrationTasks/v4")
Call<JSONArray> listTaskByStage(@Query("status") String status );
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@GET("/api/so-orchestrationTasks/v4/{taskId}")
Call<SOTask> getTaskById(@Path("taskId") String taskId);
- @Headers({ "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==", "Accept: application/json" })
@GET("/api/so-orchestrationTasks/v4/{taskId}")
Call<SOTask> getTaskByIdD(@Path("taskId") String taskId);
-
- @Headers({ "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==", "Accept: application/json" })
+
@PUT("/api/so-orchestrationTasks/v4/{taskId}")
Call<ResponseBody> updateService(@Path("taskId") String taskId, @Body RequestBody body);
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@POST("/api/so-orchestrationTasks/v4/{taskId}/commit")
Call<ResponseBody> commitTask(@Path("taskId") String taskId);
-
- @Headers({
- "X-TransactionId: 9999",
- "X-FromAppId: onap-cli",
- "Authorization: Basic SW5mcmFQb3J0YWxDbGllbnQ6cGFzc3dvcmQxJA==",
- "Accept: application/json"
- })
@POST("/api/so-serviceInstances/v3")
Call<CreateResponse> submitOrders(@Body RequestBody body);
}
server.ssl.protocol=TLS
server.ssl.key-store=classpath:keystore/uuiServer.jks
server.ssl.key-store-password=Aa123456
-server.ssl.key-store-type=JKS
\ No newline at end of file
+server.ssl.key-store-type=JKS
+
+intents.scheduledTask.enabled=false
+
+uui-server.client.aai.baseUrl=http://aai.onap
+uui-server.client.aai.username=AAI
+uui-server.client.aai.password=AAI
+uui-server.client.so.baseUrl=http://so.onap:8080
+uui-server.client.so.username=InfraPortalClient
+uui-server.client.so.password=password1
+uui-server.slicing.service-invariant-uuid=defaultServiceInvariantUuid
+uui-server.slicing.service-uuid=defaultServiceUuid
+uui-server.slicing.global-subscriber-id=defaultGlobalSubscriberId
+uui-server.slicing.service-type=defaultServiceType
--- /dev/null
+/**
+ * Copyright 2025 Deutsche Telekom.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.onap.usecaseui.server.service.csmf.impl;
+
+import static com.github.tomakehurst.wiremock.client.WireMock.aResponse;
+import static com.github.tomakehurst.wiremock.client.WireMock.equalTo;
+import static com.github.tomakehurst.wiremock.client.WireMock.equalToJson;
+import static com.github.tomakehurst.wiremock.client.WireMock.get;
+import static com.github.tomakehurst.wiremock.client.WireMock.post;
+import static com.github.tomakehurst.wiremock.client.WireMock.stubFor;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.onap.usecaseui.server.bean.csmf.OrderInfo;
+import org.onap.usecaseui.server.bean.csmf.OrderList;
+import org.onap.usecaseui.server.bean.csmf.ServiceCreateResult;
+import org.onap.usecaseui.server.bean.csmf.SlicingOrder;
+import org.onap.usecaseui.server.bean.csmf.SlicingOrderDetail;
+import org.onap.usecaseui.server.bean.nsmf.common.ServiceResult;
+import org.onap.usecaseui.server.config.AAIClientConfig;
+import org.onap.usecaseui.server.config.SOClientConfig;
+import org.onap.usecaseui.server.constant.csmf.CsmfParamConstant;
+import org.onap.usecaseui.server.constant.nsmf.NsmfParamConstant;
+import org.onap.usecaseui.server.service.csmf.SlicingService;
+import org.onap.usecaseui.server.service.csmf.config.SlicingProperties;
+import org.onap.usecaseui.server.service.lcm.ServiceLcmService;
+import org.onap.usecaseui.server.service.lcm.domain.aai.bean.AAICustomer;
+import org.onap.usecaseui.server.service.lcm.impl.DefaultServiceLcmService;
+import org.onap.usecaseui.server.service.slicingdomain.aai.AAISliceService;
+import org.onap.usecaseui.server.service.slicingdomain.so.SOSliceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.http.HttpHeaders;
+import org.wiremock.spring.EnableWireMock;
+
+import lombok.SneakyThrows;
+
+@EnableWireMock
+@EnableConfigurationProperties
+@SpringBootTest(
+ webEnvironment = WebEnvironment.RANDOM_PORT,
+ classes = {
+ AAIClientConfig.class,
+ SOClientConfig.class,
+ SlicingServiceImpl.class,
+ SlicingProperties.class,
+ DefaultServiceLcmService.class,
+ },
+ properties = {
+ "spring.main.web-application-type=none", // only temporary
+ "uui-server.client.aai.baseUrl=${wiremock.server.baseUrl}",
+ "uui-server.client.aai.username=AAI",
+ "uui-server.client.aai.password=AAI",
+ "uui-server.client.so.baseUrl=${wiremock.server.baseUrl}",
+ "uui-server.client.so.username=InfraPortalClient",
+ "uui-server.client.so.password=password1",
+ "uui-server.slicing.service-invariant-uuid=someServiceInvariantUuid",
+ "uui-server.slicing.service-uuid=someServiceUuid",
+ "uui-server.slicing.global-subscriber-id=someGlobalSubscriberId",
+ "uui-server.slicing.service-type=someServiceType",
+ })
+public class SlicingServiceImplIntegrationTest {
+
+ @MockBean ServiceLcmService serviceLcmService;
+ @Autowired AAISliceService aaiSliceService;
+ @Autowired SOSliceService soSliceService;
+ @Autowired SlicingProperties slicingProperties;
+
+ SlicingService slicingService;
+
+ @Value("${uui-server.client.so.username}")
+ String soUsername;
+
+ @Value("${uui-server.client.so.password}")
+ String soPassword;
+
+ @Value("${uui-server.client.aai.username}")
+ String aaiUsername;
+
+ @Value("${uui-server.client.aai.password}")
+ String aaiPassword;
+
+ @BeforeEach
+ void setup() {
+ slicingService = new SlicingServiceImpl(serviceLcmService,aaiSliceService,soSliceService, slicingProperties);
+ }
+
+ @Test
+ @SneakyThrows
+ void thatSORequestsAreCorrect() {
+ byte[] requestBytes = Files.readAllBytes(Paths.get("src/test/resources/__files/requests/submitOrdersRequest.json"));
+ String expectedRequestBody = new String(requestBytes, StandardCharsets.UTF_8);
+ stubFor(
+ post("/api/so-serviceInstances/v3")
+ .withBasicAuth(soUsername, soPassword)
+ .withHeader(HttpHeaders.ACCEPT, equalTo("application/json"))
+ .withHeader("X-TransactionId", equalTo("9999"))
+ .withHeader("X-FromAppId", equalTo("onap-cli"))
+ .withRequestBody(equalToJson(expectedRequestBody))
+ .willReturn(
+ aResponse().withBodyFile("submitOrdersResponse.json")
+ ));
+
+ SlicingOrder slicingOrder = new SlicingOrder();
+ SlicingOrderDetail detail = new SlicingOrderDetail();
+ detail.setLatency(10);
+ detail.setMaxNumberofUEs(10);
+ slicingOrder.setSlicing_order_info(detail);
+ ServiceResult serviceResult = slicingService.createSlicingService(slicingOrder);
+ ServiceCreateResult result = (ServiceCreateResult) serviceResult.getResult_body();
+ assertEquals("someServiceId", result.getService_id());
+ assertEquals("someOperationId", result.getOperation_id());
+ }
+
+ @Test
+ void thatSlicingOrdersCanBeListed() {
+ stubFor(
+ get(String.format("/api/aai-business/v13/customers/customer/%s/service-subscriptions/service-subscription/%s/service-instances?service-role=communication-service", "5GCustomer", "5G"))
+ .withBasicAuth(aaiUsername, aaiPassword)
+ .withHeader(HttpHeaders.ACCEPT, equalTo("application/json"))
+ .withHeader("X-TransactionId", equalTo("7777"))
+ .withHeader("X-FromAppId", equalTo("uui"))
+ .willReturn(
+ aResponse().withBodyFile("serviceInstancesResponse.json")
+ ));
+
+ ServiceResult result = slicingService.querySlicingOrderList(CsmfParamConstant.ALL, "1","10");
+
+ assertNotNull(result);
+ OrderList orderList = (OrderList) result.getResult_body();
+ assertEquals(2, orderList.getRecord_number());
+ OrderInfo orderInfo1 = orderList.getSlicing_order_list().get(0);
+ assertEquals("97740f7b-e205-48e9-819b-2ad997d78286", orderInfo1.getOrder_id());
+ assertEquals("1", orderInfo1.getOrder_index());
+ assertEquals("5G-smth", orderInfo1.getOrder_name());
+ assertEquals("Assigned", orderInfo1.getOrder_status());
+ assertEquals("General_Revenue-Bearing", orderInfo1.getService_snssai());
+ OrderInfo orderInfo2 = orderList.getSlicing_order_list().get(1);
+ assertEquals("97732f7b-e205-48e9-819b-2ad997d78286", orderInfo2.getOrder_id());
+ assertEquals("2", orderInfo2.getOrder_index());
+ assertEquals("5G-smth-else", orderInfo2.getOrder_name());
+ assertEquals("Assigned", orderInfo2.getOrder_status());
+ assertEquals("General_Revenue-Bearing", orderInfo2.getService_snssai());
+ }
+}
import org.onap.usecaseui.server.bean.csmf.SlicingOrderDetail;
import org.onap.usecaseui.server.constant.nsmf.NsmfParamConstant;
import org.onap.usecaseui.server.controller.IntentController;
+import org.onap.usecaseui.server.service.csmf.config.SlicingProperties;
import org.onap.usecaseui.server.service.lcm.ServiceLcmService;
import org.onap.usecaseui.server.service.lcm.impl.DefaultServiceLcmService;
import org.onap.usecaseui.server.service.slicingdomain.aai.AAISliceService;
SOSliceService soSliceService;
AAISliceService aaiSliceService;
ServiceLcmService serviceLcmService;
+ SlicingProperties slicingProperties;
@Before
public void before() throws Exception {
aaiSliceService = mock(AAISliceService.class);
soSliceService = mock(SOSliceService.class);
serviceLcmService = mock(DefaultServiceLcmService.class);
- slicingService = new SlicingServiceImpl(aaiSliceService, soSliceService);
+ slicingProperties = mock(SlicingProperties.class);
+ slicingService = new SlicingServiceImpl(serviceLcmService, aaiSliceService, soSliceService, slicingProperties);
MemberModifier.field(SlicingServiceImpl.class, "serviceLcmService").set(slicingService , serviceLcmService);
}
},
properties = {
"spring.main.web-application-type=none", // only temporary
- "client.aai.baseUrl=${wiremock.server.baseUrl}",
- "client.aai.username=AAI",
- "client.aai.password=AAI"
+ "uui-server.client.aai.baseUrl=${wiremock.server.baseUrl}",
+ "uui-server.client.aai.username=AAI",
+ "uui-server.client.aai.password=AAI"
})
public class DefaultCustomerServiceIntegrationTest {
@Autowired
CustomerService customerService;
- @Value("${client.aai.username}")
+ @Value("${uui-server.client.aai.username}")
String username;
- @Value("${client.aai.password}")
+ @Value("${uui-server.client.aai.password}")
String password;
@Test
import org.onap.usecaseui.server.service.lcm.domain.so.bean.ServiceOperation;
import org.onap.usecaseui.server.service.lcm.domain.so.exceptions.SOException;
+import jakarta.persistence.EntityManagerFactory;
import jakarta.servlet.ReadListener;
import jakarta.servlet.ServletInputStream;
import jakarta.servlet.http.HttpServletRequest;
import static org.onap.usecaseui.server.util.CallStub.successfulCall;
public class DefaultServiceLcmServiceTest {
-
+
private static final long serialVersionUID = 1L;
-
+
+ private final EntityManagerFactory entityManagerFactory = mock(EntityManagerFactory.class);
+
ServiceLcmService service = null;
-
+
@Before
public void before() throws Exception {
SOService soService = mock(SOService.class);
- service = new DefaultServiceLcmService(soService);
+ service = new DefaultServiceLcmService(entityManagerFactory, soService);
}
-
+
@Test
public void itCanInstantiateService() throws IOException {
SOService soService = mock(SOService.class);
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
Assert.assertSame(operation, service.instantiateService(request));
}
when(soService.instantiateService(Mockito.any())).thenReturn(failedCall("SO is not available!"));
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.instantiateService(request);
}
when(soService.instantiateService(Mockito.any())).thenReturn(emptyBodyCall());
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.instantiateService(request);
}
when(soService.terminateService(eq(serviceId), Mockito.any())).thenReturn(successfulCall(rsp));
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
Assert.assertSame(rsp, service.terminateService(serviceId, request));
}
when(soService.terminateService(eq(serviceId), Mockito.any())).thenReturn(failedCall("SO is not available!"));
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.terminateService(serviceId, request);
}
when(soService.terminateService(eq(serviceId), Mockito.any())).thenReturn(emptyBodyCall());
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.terminateService(serviceId, request);
}
OperationProgressInformation progress = new OperationProgressInformation();
when(soService.queryOperationProgress(serviceId, operationId)).thenReturn(successfulCall(progress));
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
Assert.assertSame(progress, service.queryOperationProgress(serviceId, operationId));
}
String operationId = "1";
when(soService.queryOperationProgress(serviceId, operationId)).thenReturn(failedCall("SO is not available!"));
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.queryOperationProgress(serviceId, operationId);
}
String operationId = "1";
when(soService.queryOperationProgress(serviceId, operationId)).thenReturn(emptyBodyCall());
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.queryOperationProgress(serviceId, operationId);
}
-
+
@Test(expected = SOException.class)
public void scaleServiceWillThrowExceptionWhenSOIsNotAvailable() throws IOException {
SOService soService = mock(SOService.class);
when(soService.scaleService(eq(serviceId), Mockito.any())).thenReturn(failedCall("SO is not available!"));
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.scaleService(serviceId, request);
}
when(soService.scaleService(eq(serviceId), Mockito.any())).thenReturn(emptyBodyCall());
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.scaleService(serviceId, request);
}
-
+
@Test
public void itCanScaleService() throws IOException {
SOService soService = mock(SOService.class);
when(soService.scaleService(eq(serviceId), Mockito.any())).thenReturn(successfulCall(rsp));
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
Assert.assertSame(rsp, service.scaleService(serviceId, request));
}
-
+
@Test(expected = SOException.class)
public void updateServiceWillThrowExceptionWhenSOIsNotAvailable() throws IOException {
SOService soService = mock(SOService.class);
when(soService.updateService(eq(serviceId), Mockito.any())).thenReturn(failedCall("SO is not available!"));
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.updateService(serviceId, request);
}
@Test(expected = SOException.class)
public void updateServiceWillThrowExceptionWhenSOResponseError() throws IOException {
SOService soService = mock(SOService.class);
+
String serviceId = "1";
when(soService.updateService(eq(serviceId), Mockito.any())).thenReturn(emptyBodyCall());
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
service.updateService(serviceId, request);
}
-
+
@Test
public void itCanUpdateService() throws IOException {
SOService soService = mock(SOService.class);
+ EntityManagerFactory entityManagerFactory = mock(EntityManagerFactory.class);
String serviceId = "1";
SaveOrUpdateOperationRsp rsp = new SaveOrUpdateOperationRsp();
rsp.setOperationId("1");
when(soService.updateService(eq(serviceId), Mockito.any())).thenReturn(successfulCall(rsp));
HttpServletRequest request = mockRequest();
- ServiceLcmService service = new DefaultServiceLcmService(soService);
+ ServiceLcmService service = new DefaultServiceLcmService(entityManagerFactory, soService);
Assert.assertSame(rsp, service.updateService(serviceId, request));
}
-}
\ No newline at end of file
+}
--- /dev/null
+{
+ "service": {
+ "description": "",
+ "serviceInvariantUuid": "someServiceInvariantUuid",
+ "serviceUuid": "someServiceUuid",
+ "globalSubscriberId": "someGlobalSubscriberId",
+ "serviceType": "someServiceType",
+ "parameters": {
+ "requestInputs": {
+ "latency": 10,
+ "maxNumberofUEs": 10,
+ "useInterval": "20"
+ }
+ }
+ }
+}
--- /dev/null
+{
+ "service-instance": [
+ {
+ "service-instance-id": "97740f7b-e205-48e9-819b-2ad997d78286",
+ "service-instance-name": "5G-smth",
+ "service-type": "5G",
+ "environment-context": "General_Revenue-Bearing",
+ "workload-context": "Production",
+ "model-invariant-id": "f367053b-55ca-4074-9322-c102aed93f4f",
+ "model-version-id": "e70da80f-4df7-4be7-89c5-2ae4fdfd0f48",
+ "resource-version": "1699950946612",
+ "selflink": "restconf/config/GENERIC-RESOURCE-API:services/service/97740f7b-e205-48e9-819b-2ad997d78286/service-data/service-topology/",
+ "orchestration-status": "Assigned",
+ "input-parameters": "[]",
+ "relationship-list": {
+ "relationship": [
+ {
+ "related-to": "owning-entity",
+ "relationship-label": "org.onap.relationships.inventory.BelongsTo",
+ "related-link": "/aai/v30/business/owning-entities/owning-entity/59d660dc-4aeb-4058-9bb9-c2bd2a0bcb72",
+ "relationship-data": [
+ {
+ "relationship-key": "owning-entity.owning-entity-id",
+ "relationship-value": "59d660dc-4aeb-4058-9bb9-c2bd2a0bcb72"
+ }
+ ]
+ }
+ ]
+ }
+ },
+ {
+ "service-instance-id": "97732f7b-e205-48e9-819b-2ad997d78286",
+ "service-instance-name": "5G-smth-else",
+ "service-type": "5G",
+ "environment-context": "General_Revenue-Bearing",
+ "workload-context": "Production",
+ "model-invariant-id": "f367053b-55ca-4074-9322-c102aed93f4f",
+ "model-version-id": "e70da80f-4df7-4be7-89c5-2ae4fdfd0f48",
+ "resource-version": "1699950946613",
+ "selflink": "restconf/config/GENERIC-RESOURCE-API:services/service/97732f7b-e205-48e9-819b-2ad997d78286/service-data/service-topology/",
+ "orchestration-status": "Assigned",
+ "input-parameters": "[]",
+ "relationship-list": {
+ "relationship": [
+ {
+ "related-to": "owning-entity",
+ "relationship-label": "org.onap.relationships.inventory.BelongsTo",
+ "related-link": "/aai/v30/business/owning-entities/owning-entity/59d660dc-4aeb-4058-9bb9-c2bd2a0bcb72",
+ "relationship-data": [
+ {
+ "relationship-key": "owning-entity.owning-entity-id",
+ "relationship-value": "59d660dc-4aeb-4058-9bb9-c2bd2a0bcb72"
+ }
+ ]
+ }
+ ]
+ }
+ }
+ ]
+}
--- /dev/null
+{
+ "service": {
+ "serviceId": "someServiceId",
+ "operationId": "someOperationId"
+ }
+}
Code Review / usecase-ui / server.git / commitdiff