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                 logger.info("updateTaskAuditInfo: the requestBody body is:{}", jsonstr);
 207                 RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), jsonstr);
 208                 Response<ResponseBody> updateResponse = soSliceService
 209                     .updateService(slicingTaskAuditInfo.getTaskId(), requestBody).execute();
 210
 211                 if (updateResponse.isSuccessful()) {
 212                     Response<ResponseBody> commitResponse = this.soSliceService
 213                         .commitTask(slicingTaskAuditInfo.getTaskId()).execute();
 214                     if (commitResponse.isSuccessful()) {
 215                         resultMsg = "5G slicing task submit result.";
 216                         resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 217                     } else {
 218                         logger.error(String.format("updateTaskAuditInfo: Can not commitTask [code={}, message={}]",
 219                             commitResponse.code(),
 220                             commitResponse.message()));
 221                         resultMsg = "5G slicing task submit failed.";
 222                         resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 223                     }
 224                 } else {
 225                     logger.error(String
 226                         .format("updateTaskAuditInfo: Can not updateService [code={}, message={}]", response.code(),
 227                             response.message()));
 228                     resultMsg = "5G slicing task submit failed.";
 229                     resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 230                 }
 231             } else {
 232                 logger.error(String.format("updateTaskAuditInfo: Can not get slicingTaskAuditInfo[code={}, message={}]",
 233                     response.code(),
 234                     response.message()));
 235                 resultMsg = "5G slicing task submit failed.";
 236                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 237             }
 238         } catch (Exception e) {
 239             resultMsg = "5G slicing task submit failed. Unknown exception occurred!";
 240             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 241             logger.error(e.getMessage());
 242         }
 243
 244         logger.info(resultMsg);
 245         logger.info("updateTaskAuditInfo: 5G slicing task submit has been finished.");
 246         resultHeader.setResult_message(resultMsg);
 247         serviceResult.setResult_header(resultHeader);
 248         return serviceResult;
 249     }
 250
 251     @Override
 252     public ServiceResult queryTaskCreationInfo(String taskId) {
 253         ServiceResult serviceResult = new ServiceResult();
 254         ResultHeader resultHeader = new ResultHeader();
 255
 256         SlicingTaskCreationInfo slicingTaskCreationInfo = new SlicingTaskCreationInfo();
 257         String resultMsg;
 258
 259         try {
 260             // TODO
 261             Response<SOTask> response = this.soSliceService.getTaskByIdD(taskId).execute();
 262             if (response.isSuccessful()) {
 263                 Gson gson = new Gson();
 264                 SOTask soTask = response.body();
 265                 logger.info("updateTaskAuditInfo: getTaskById response is:{}", gson.toJson(soTask));
 266                 taskMgtServiceConvert.convertTaskCreationInfo(slicingTaskCreationInfo, soTask);
 267                 // return normal result code
 268                 resultMsg = "5G slicing task creation infomation query result.";
 269                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 270             } else {
 271                 logger.error(String
 272                     .format("updateTaskAuditInfo: Can not get slicingTaskCreationInfo[code={}, message={}]",
 273                         response.code(),
 274                         response.message()));
 275                 resultMsg = "5G slicing task creation infomation query failed.";
 276                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 277             }
 278         } catch (Exception e) {
 279             resultMsg = "5G slicing task creation infomation query failed. Unknown exception occurred!";
 280             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 281             logger.error(e.getMessage());
 282         }
 283
 284         logger.info(resultMsg);
 285         logger.info("updateTaskAuditInfo: 5G slicing task creation infomation query has been finished.");
 286         resultHeader.setResult_message(resultMsg);
 287         serviceResult.setResult_header(resultHeader);
 288         serviceResult.setResult_body(slicingTaskCreationInfo);
 289         return serviceResult;
 290     }
 291
 292     @Override
 293     public ServiceResult queryTaskCreationProgress(String taskId) {
 294         ServiceResult serviceResult = new ServiceResult();
 295         ResultHeader resultHeader = new ResultHeader();
 296
 297         SlicingTaskCreationProgress slicingTaskCreationProgress = new SlicingTaskCreationProgress();
 298         String resultMsg;
 299
 300         try {
 301             // TODO
 302             Response<SOTask> response = this.soSliceService.getTaskByIdD(taskId).execute();
 303             if (response.isSuccessful()) {
 304                 SOTask soTask = response.body();
 305                 Gson gson = new Gson();
 306                 logger.info("queryTaskCreationProgress: getTaskById response is:{}", gson.toJson(soTask));
 307                 taskMgtServiceConvert.convertTaskCreationProgress(slicingTaskCreationProgress, soTask);
 308                 resultMsg = "5G slicing task operation progress query result.";
 309                 resultHeader.setResult_code(NsmfCodeConstant.SUCCESS_CODE);
 310             } else {
 311                 logger.error(String
 312                     .format("queryTaskCreationProgress: Can not get slicingTaskCreationProgress[code={}, message={}]",
 313                         response.code(), response.message()));
 314                 resultMsg = "5G slicing task operation progress query failed.";
 315                 resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 316             }
 317         } catch (Exception e) {
 318             resultMsg = "5G slicing task operation progress query failed. Unknown exception occurred!";
 319             resultHeader.setResult_code(NsmfCodeConstant.ERROR_CODE_UNKNOWN);
 320             logger.error(e.getMessage());
 321         }
 322
 323         logger.info(resultMsg);
 324         logger.info("queryTaskCreationProgress: 5G slicing task operation progress has been finished.");
 325         resultHeader.setResult_message(resultMsg);
 326         serviceResult.setResult_header(resultHeader);
 327         serviceResult.setResult_body(slicingTaskCreationProgress);
 328         return serviceResult;
 329     }
 330 }