server/src/main/java/org/onap/usecaseui/server/service/nsmf/impl/TaskMgtServiceImpl.java

   1 /*
   2  * Copyright (C) 2019 CMCC, Inc. and others. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.onap.usecaseui.server.service.nsmf.impl;
  17
  18 import java.lang.reflect.Type;
  19 import java.util.List;
  20
  21 import com.alibaba.fastjson.JSON;
  22 import com.alibaba.fastjson.JSONArray;
  23 import com.google.gson.Gson;
  24 import com.google.gson.reflect.TypeToken;
  25
  26 import javax.annotation.Resource;
  27 import okhttp3.MediaType;
  28 import okhttp3.RequestBody;
  29 import okhttp3.ResponseBody;
  30 import org.onap.usecaseui.server.bean.nsmf.common.ResultHeader;
  31 import org.onap.usecaseui.server.bean.nsmf.common.ServiceResult;
  32 import org.onap.usecaseui.server.bean.nsmf.task.SlicingTaskAuditInfo;
  33 import org.onap.usecaseui.server.bean.nsmf.task.SlicingTaskCreationInfo;
  34 import org.onap.usecaseui.server.bean.nsmf.task.SlicingTaskCreationProgress;
  35 import org.onap.usecaseui.server.bean.nsmf.task.SlicingTaskList;
  36 import org.onap.usecaseui.server.constant.nsmf.NsmfCodeConstant;
  37
  38 import org.onap.usecaseui.server.service.nsmf.TaskMgtService;
  39 import org.onap.usecaseui.server.service.slicingdomain.so.SOSliceService;
  40 import org.onap.usecaseui.server.service.slicingdomain.so.bean.SOTask;
  41 import org.onap.usecaseui.server.service.slicingdomain.so.bean.SOTaskRsp;
  42 import org.onap.usecaseui.server.util.RestfulServices;
  43 import org.slf4j.Logger;
  44 import org.slf4j.LoggerFactory;
  45 import org.springframework.context.annotation.EnableAspectJAutoProxy;
  46 import org.springframework.stereotype.Service;
  47 import retrofit2.Response;
  48
  49 @Service("TaskMgtService")
  50 @org.springframework.context.annotation.Configuration
  51 @EnableAspectJAutoProxy
  52 public class TaskMgtServiceImpl implements TaskMgtService {
  53
  54     private static final Logger logger = LoggerFactory.getLogger(TaskMgtServiceImpl.class);
  55
  56     @Resource(name = "TaskMgtConvertService")
  57     private TaskMgtServiceConvert taskMgtServiceConvert;
  58
  59     private SOSliceService soSliceService;
  60
  61     public TaskMgtServiceImpl() {
  62         this(RestfulServices.create(SOSliceService.class));
  63     }
  64
  65     public TaskMgtServiceImpl(SOSliceService soSliceService) {
  66         this.soSliceService = soSliceService;
  67     }
  68
  69     @Override
  70     public ServiceResult querySlicingTask(int pageNo, int pageSize) {
  71
  72         ServiceResult serviceResult = new ServiceResult();
  73         ResultHeader resultHeader = new ResultHeader();
  74
  75         SlicingTaskList slicingTaskList = new SlicingTaskList();
  76         SOTaskRsp soTaskRsp = new SOTaskRsp();
  77         String resultMsg;
  78
  79         try {
  80             Response<JSONArray> response = this.soSliceService.listTask().execute();
  81             if (response.isSuccessful()) {
  82                 Gson gson = new Gson();
  83                 Type type = new TypeToken<List<SOTask>>() {
  84                 }.getType();
  85                 soTaskRsp.setTask(gson.fromJson(response.body().toString(), type));
  86                 logger.info("querySlicingTask: listTask response is:{}", response.body().toString());
  87                 taskMgtServiceConvert.convertSlicingTaskList(slicingTaskList, soTaskRsp, pageNo, pageSize);
  88                 resultMsg = "5G slicing task query result.";
  89                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
  90             } else {
  91                 logger.error(
  92                     String.format("querySlicingTask: Can not get slicingTaskList[code={}, message={}]", response.code(),
  93                         response.message()));
  94                 resultMsg = "5G slicing task result query failed!";
  95                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
  96             }
  97         } catch (Exception e) {
  98             resultMsg = "5G slicing task result query failed. Unknown exception occurred!";
  99             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 100             logger.error(e.getMessage());
 101         }
 102
 103         logger.info(resultMsg);
 104         logger.info("querySlicingTask: 5G slicing task result query has been finished.");
 105         resultHeader.setResult_message(resultMsg);
 106         serviceResult.setResult_header(resultHeader);
 107         serviceResult.setResult_body(slicingTaskList);
 108         return serviceResult;
 109     }
 110
 111     @Override
 112     public ServiceResult querySlicingTaskByStatus(String status, int pageNo, int pageSize) {
 113
 114         ServiceResult serviceResult = new ServiceResult();
 115         ResultHeader resultHeader = new ResultHeader();
 116
 117         SlicingTaskList slicingTaskList = new SlicingTaskList();
 118         SOTaskRsp soTaskRsp = new SOTaskRsp();
 119         String resultMsg;
 120         try {
 121             Response<JSONArray> response = this.soSliceService.listTaskByStage(status).execute();
 122             if (response.isSuccessful()) {
 123                 Gson gson = new Gson();
 124                 Type type = new TypeToken<List<SOTask>>() {
 125                 }.getType();
 126                 soTaskRsp.setTask(gson.fromJson(response.body().toString(), type));
 127                 logger.info("querySlicingTaskByStatus: listTaskByStage response is:{}", response.body().toString());
 128                 taskMgtServiceConvert.convertSlicingTaskList(slicingTaskList, soTaskRsp, pageNo, pageSize);
 129                 resultMsg = "5G slicing task query based on status result.";
 130                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 131             } else {
 132                 logger.error(String.format("querySlicingTaskByStatus: Can not get slicingTaskList[code={}, message={}]",
 133                     response.code(),
 134                     response.message()));
 135                 resultMsg = "5G slicing task result query based on status failed. ";
 136                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 137             }
 138         } catch (Exception e) {
 139             resultMsg = "5G slicing task result query based on status failed. Unknown exception occurred!";
 140             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 141             logger.error(e.getMessage());
 142         }
 143
 144         logger.info(resultMsg);
 145         logger.info("querySlicingTaskByStatus: 5G slicing task result query based on status has been finished.");
 146         resultHeader.setResult_message(resultMsg);
 147         serviceResult.setResult_header(resultHeader);
 148         serviceResult.setResult_body(slicingTaskList);
 149         return serviceResult;
 150     }
 151
 152     @Override
 153     public ServiceResult queryTaskAuditInfo(String taskId) {
 154         ServiceResult serviceResult = new ServiceResult();
 155         ResultHeader resultHeader = new ResultHeader();
 156
 157         SlicingTaskAuditInfo slicingTaskAuditInfo = new SlicingTaskAuditInfo();
 158         String resultMsg = "";
 159
 160         try {
 161             // TODO
 162             Response<SOTask> response = this.soSliceService.getTaskById(taskId).execute();
 163             if (response.isSuccessful()) {
 164                 SOTask soTaskInfo = response.body();
 165                 Gson gson = new Gson();
 166                 logger.info("queryTaskAuditInfo: getTaskById response is:{}", gson.toJson(soTaskInfo));
 167                 taskMgtServiceConvert.convertTaskAuditInfo(slicingTaskAuditInfo, soTaskInfo);
 168                 // return normal result code
 169                 resultMsg = "5G slicing task configure audit information query result.";
 170                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 171             } else {
 172                 logger.error(String.format("queryTaskAuditInfo: Can not get slicingTaskAuditInfo[code={}, message={}]",
 173                     response.code(),
 174                     response.message()));
 175                 resultMsg = "5G slicing task configure audit information query failed.";
 176                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 177             }
 178         } catch (Exception e) {
 179             resultMsg = "5G slicing task configure audit information query failed. Unknown exception occurred!";
 180             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 181             logger.error(e.getMessage());
 182         }
 183
 184         logger.info(resultMsg);
 185         logger.info("queryTaskAuditInfo: 5G slicing task configure audit information query has been finished.");
 186         resultHeader.setResult_message(resultMsg);
 187         serviceResult.setResult_header(resultHeader);
 188         serviceResult.setResult_body(slicingTaskAuditInfo);
 189         return serviceResult;
 190     }
 191
 192     public ServiceResult updateTaskAuditInfo(SlicingTaskAuditInfo slicingTaskAuditInfo) {
 193         ServiceResult serviceResult = new ServiceResult();
 194         ResultHeader resultHeader = new ResultHeader();
 195         String resultMsg;
 196         try {
 197             // TODO
 198             Response<SOTask> response = this.soSliceService.getTaskById(slicingTaskAuditInfo.getTaskId()).execute();
 199             if (response.isSuccessful()) {
 200                 SOTask soTaskInfo = response.body();
 201                 Gson gson = new Gson();
 202                 logger.info("updateTaskAuditInfo: getTaskById response is:{}", gson.toJson(soTaskInfo));
 203                 taskMgtServiceConvert.convertTaskAuditToSoTask(soTaskInfo, slicingTaskAuditInfo);
 204
 205                 String jsonstr = JSON.toJSONString(soTaskInfo);
 206                 RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), jsonstr);
 207                 Response<ResponseBody> updateResponse = soSliceService
 208                     .updateService(slicingTaskAuditInfo.getTaskId(), requestBody).execute();
 209
 210                 if (updateResponse.isSuccessful()) {
 211                     Response<ResponseBody> commitResponse = this.soSliceService
 212                         .commitTask(slicingTaskAuditInfo.getTaskId()).execute();
 213                     if (commitResponse.isSuccessful()) {
 214                         resultMsg = "5G slicing task submit result.";
 215                         resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 216                     } else {
 217                         logger.error(String.format("updateTaskAuditInfo: Can not commitTask [code={}, message={}]",
 218                             commitResponse.code(),
 219                             commitResponse.message()));
 220                         resultMsg = "5G slicing task submit failed.";
 221                         resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 222                     }
 223                 } else {
 224                     logger.error(String
 225                         .format("updateTaskAuditInfo: Can not updateService [code={}, message={}]", response.code(),
 226                             response.message()));
 227                     resultMsg = "5G slicing task submit failed.";
 228                     resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 229                 }
 230             } else {
 231                 logger.error(String.format("updateTaskAuditInfo: Can not get slicingTaskAuditInfo[code={}, message={}]",
 232                     response.code(),
 233                     response.message()));
 234                 resultMsg = "5G slicing task submit failed.";
 235                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 236             }
 237         } catch (Exception e) {
 238             resultMsg = "5G slicing task submit failed. Unknown exception occurred!";
 239             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 240             logger.error(e.getMessage());
 241         }
 242
 243         logger.info(resultMsg);
 244         logger.info("updateTaskAuditInfo: 5G slicing task submit has been finished.");
 245         resultHeader.setResult_message(resultMsg);
 246         serviceResult.setResult_header(resultHeader);
 247         return serviceResult;
 248     }
 249
 250     @Override
 251     public ServiceResult queryTaskCreationInfo(String taskId) {
 252         ServiceResult serviceResult = new ServiceResult();
 253         ResultHeader resultHeader = new ResultHeader();
 254
 255         SlicingTaskCreationInfo slicingTaskCreationInfo = new SlicingTaskCreationInfo();
 256         String resultMsg;
 257
 258         try {
 259             // TODO
 260             Response<SOTask> response = this.soSliceService.getTaskByIdD(taskId).execute();
 261             if (response.isSuccessful()) {
 262                 Gson gson = new Gson();
 263                 SOTask soTask = response.body();
 264                 logger.info("updateTaskAuditInfo: getTaskById response is:{}", gson.toJson(soTask));
 265                 taskMgtServiceConvert.convertTaskCreationInfo(slicingTaskCreationInfo, soTask);
 266                 // return normal result code
 267                 resultMsg = "5G slicing task creation infomation query result.";
 268                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 269             } else {
 270                 logger.error(String
 271                     .format("updateTaskAuditInfo: Can not get slicingTaskCreationInfo[code={}, message={}]",
 272                         response.code(),
 273                         response.message()));
 274                 resultMsg = "5G slicing task creation infomation query failed.";
 275                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 276             }
 277         } catch (Exception e) {
 278             resultMsg = "5G slicing task creation infomation query failed. Unknown exception occurred!";
 279             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 280             logger.error(e.getMessage());
 281         }
 282
 283         logger.info(resultMsg);
 284         logger.info("updateTaskAuditInfo: 5G slicing task creation infomation query has been finished.");
 285         resultHeader.setResult_message(resultMsg);
 286         serviceResult.setResult_header(resultHeader);
 287         serviceResult.setResult_body(slicingTaskCreationInfo);
 288         return serviceResult;
 289     }
 290
 291     @Override
 292     public ServiceResult queryTaskCreationProgress(String taskId) {
 293         ServiceResult serviceResult = new ServiceResult();
 294         ResultHeader resultHeader = new ResultHeader();
 295
 296         SlicingTaskCreationProgress slicingTaskCreationProgress = new SlicingTaskCreationProgress();
 297         String resultMsg;
 298
 299         try {
 300             // TODO
 301             Response<SOTask> response = this.soSliceService.getTaskByIdD(taskId).execute();
 302             if (response.isSuccessful()) {
 303                 SOTask soTask = response.body();
 304                 Gson gson = new Gson();
 305                 logger.info("queryTaskCreationProgress: getTaskById response is:{}", gson.toJson(soTask));
 306                 taskMgtServiceConvert.convertTaskCreationProgress(slicingTaskCreationProgress, soTask);
 307                 resultMsg = "5G slicing task operation progress query result.";
 308                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 309             } else {
 310                 logger.error(String
 311                     .format("queryTaskCreationProgress: Can not get slicingTaskCreationProgress[code={}, message={}]",
 312                         response.code(), response.message()));
 313                 resultMsg = "5G slicing task operation progress query failed.";
 314                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 315             }
 316         } catch (Exception e) {
 317             resultMsg = "5G slicing task operation progress query failed. Unknown exception occurred!";
 318             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 319             logger.error(e.getMessage());
 320         }
 321
 322         logger.info(resultMsg);
 323         logger.info("queryTaskCreationProgress: 5G slicing task operation progress has been finished.");
 324         resultHeader.setResult_message(resultMsg);
 325         serviceResult.setResult_header(resultHeader);
 326         serviceResult.setResult_body(slicingTaskCreationProgress);
 327         return serviceResult;
 328     }
 329 }