gerrit.onap Code Review - usecase-ui/llm-adaptation.git/blob

   1 package org.onap.usecaseui.llmadaptation.service.impl;
   2
   3 import com.alibaba.fastjson2.JSONArray;
   4 import com.alibaba.fastjson2.JSONObject;
   5 import lombok.extern.slf4j.Slf4j;
   6 import org.onap.usecaseui.llmadaptation.bean.*;
   7 import org.onap.usecaseui.llmadaptation.bean.bisheng.BiShengCreateDatasetResponse;
   8 import org.onap.usecaseui.llmadaptation.bean.bisheng.ProcessFileResponse;
   9 import org.onap.usecaseui.llmadaptation.constant.BiShengConstant;
  10 import org.onap.usecaseui.llmadaptation.constant.CommonConstant;
  11 import org.onap.usecaseui.llmadaptation.mapper.DatasetMapper;
  12 import org.onap.usecaseui.llmadaptation.service.BiShengDatasetService;
  13 import org.onap.usecaseui.llmadaptation.util.TimeUtil;
  14 import org.springframework.beans.factory.annotation.Autowired;
  15 import org.springframework.core.io.buffer.DataBuffer;
  16 import org.springframework.http.ContentDisposition;
  17 import org.springframework.http.MediaType;
  18 import org.springframework.http.client.MultipartBodyBuilder;
  19 import org.springframework.http.codec.multipart.FilePart;
  20 import org.springframework.stereotype.Service;
  21 import org.springframework.web.reactive.function.BodyInserters;
  22 import org.springframework.web.reactive.function.client.WebClient;
  23 import reactor.core.publisher.Flux;
  24 import reactor.core.publisher.Mono;
  25
  26 import java.util.List;
  27
  28 import static org.springframework.http.MediaType.APPLICATION_JSON;
  29
  30 @Slf4j
  31 @Service
  32 public class BiShengDatasetServiceImpl implements BiShengDatasetService {
  33
  34     @Autowired
  35     private WebClient webClient;
  36
  37     @Autowired
  38     private DatasetMapper datasetMapper;
  39
  40
  41     @Override
  42     public Mono<ServiceResult> createDataset(Flux<FilePart> fileParts, String metaData, MaaSPlatform maaSPlatform) {
  43
  44         KnowledgeBase knowledgeBase = JSONObject.parseObject(metaData, KnowledgeBase.class);
  45         knowledgeBase.setUpdateTime(TimeUtil.getNowTime());
  46         JSONObject createParam = new JSONObject();
  47         createParam.put("description", knowledgeBase.getKnowledgeBaseDescription());
  48         createParam.put("model", maaSPlatform.getVectorModel());
  49         createParam.put("name", knowledgeBase.getKnowledgeBaseName());
  50         return webClient.post()
  51                 .uri(maaSPlatform.getServerIp() + BiShengConstant.CREATE_DATASET_URL)
  52                 .contentType(APPLICATION_JSON)
  53                 .header(CommonConstant.COOKIE, BiShengConstant.COOKIE_VALUE)
  54                 .bodyValue(createParam)
  55                 .retrieve()
  56                 .bodyToMono(BiShengCreateDatasetResponse.class)
  57                 .flatMap(response -> {
  58                     if (response.getStatus_code() != 200) {
  59                         return Mono.just(new ServiceResult(new ResultHeader(500, response.getStatus_message())));
  60                     }
  61                     int knowledgeBaseId = response.getData().getIntValue("id");
  62                     return fileParts.flatMap(filePart -> processFile(filePart, knowledgeBaseId, maaSPlatform.getServerIp()))
  63                             .then(Mono.defer(() -> {
  64                                 knowledgeBase.setKnowledgeBaseId(String.valueOf(knowledgeBaseId));
  65                                 datasetMapper.insertKnowledgeBaseRecord(knowledgeBase);
  66                                 return Mono.just(new ServiceResult(new ResultHeader(200, "create success")));
  67                             })).onErrorResume(e -> {
  68                                 log.error("Error occurred during file upload: {}", e.getMessage());
  69                                 return Mono.just(new ServiceResult(new ResultHeader(500, "file upload failed")));
  70                             });
  71                 }).onErrorResume(e -> {
  72                     log.error("Error occurred while creating dataset: {}", e.getMessage());
  73                     return Mono.just(new ServiceResult(new ResultHeader(500, "create failed")));
  74                 });
  75     }
  76
  77     private Mono<Void> processFile(FilePart filePart, int knowledgeBaseId, String serverIp) {
  78         String filename = filePart.filename();
  79         Flux<DataBuffer> content = filePart.content();
  80         MultipartBodyBuilder builder = new MultipartBodyBuilder();
  81         builder.asyncPart("file", content, DataBuffer.class)
  82                 .headers(headers -> {
  83                     ContentDisposition contentDisposition = ContentDisposition
  84                             .builder("form-data")
  85                             .name("file")
  86                             .filename(filename)
  87                             .build();
  88                     headers.setContentDisposition(contentDisposition);
  89                     headers.setContentType(MediaType.TEXT_PLAIN);
  90                 });
  91         return webClient.post()
  92                 .uri(serverIp + BiShengConstant.UPLOAD_FILE_URL)
  93                 .contentType(MediaType.MULTIPART_FORM_DATA)
  94                 .header(CommonConstant.COOKIE, BiShengConstant.COOKIE_VALUE)
  95                 .body(BodyInserters.fromMultipartData(builder.build()))
  96                 .retrieve()
  97                 .bodyToMono(BiShengCreateDatasetResponse.class)
  98                 .flatMap(response -> {
  99                     if (response.getStatus_code() != 200) {
 100                         log.error("response is {}", response);
 101                         return Mono.empty();
 102                     }
 103                     String filePath = response.getData().getString("file_path");
 104                     JSONObject processParam = new JSONObject();
 105                     processParam.put("knowledge_id", knowledgeBaseId);
 106                     JSONArray jsonArray = new JSONArray();
 107                     JSONObject jsonObject = new JSONObject();
 108                     jsonObject.put("file_path", filePath);
 109                     jsonArray.add(jsonObject);
 110                     processParam.put("file_list", jsonArray);
 111                     return webClient.post()
 112                             .uri(serverIp + BiShengConstant.PROCESS_FILE_URL)
 113                             .contentType(APPLICATION_JSON)
 114                             .header(CommonConstant.COOKIE, BiShengConstant.COOKIE_VALUE)
 115                             .bodyValue(processParam)
 116                             .retrieve()
 117                             .bodyToMono(ProcessFileResponse.class).flatMap(lastResponse -> {
 118                                 if (lastResponse.getStatus_code() == 200) {
 119                                     JSONObject data = lastResponse.getData().get(0);
 120                                     int fileId = data.getIntValue("id");
 121                                     File file = new File(String.valueOf(fileId), filename);
 122                                     datasetMapper.insertFileName(List.of(file), String.valueOf(knowledgeBaseId));
 123                                 }
 124                                 return Mono.empty();
 125                             });
 126                 });
 127     }
 128
 129     @Override
 130     public Mono<ServiceResult> removeDataset(String knowledgeBaseId, String serverIp) {
 131         return webClient.delete()
 132                 .uri(serverIp + BiShengConstant.DATASET_V2_URL + knowledgeBaseId)
 133                 .header(CommonConstant.COOKIE, BiShengConstant.COOKIE_VALUE)
 134                 .retrieve()
 135                 .bodyToMono(BiShengCreateDatasetResponse.class)
 136                 .flatMap(response -> {
 137                     if (response.getStatus_code() == 200) {
 138                         return Mono.fromRunnable(() -> {
 139                             try {
 140                                 datasetMapper.deleteKnowledgeBaseByUuid(knowledgeBaseId);
 141                                 datasetMapper.deleteFileById(knowledgeBaseId);
 142                             } catch (Exception dbException) {
 143                                 throw new RuntimeException("Database operation failed", dbException);
 144                             }
 145                         }).then(Mono.just(new ServiceResult(new ResultHeader(200, "delete success"))));
 146                     } else {
 147                         return Mono.just(new ServiceResult(new ResultHeader(500, response.getStatus_message())));
 148                     }
 149                 })
 150                 .onErrorResume(e -> {
 151                     log.error("Error occurred while delete dataset: {}", e.getMessage());
 152                     return Mono.just(new ServiceResult(new ResultHeader(500, "delete failed")));
 153                 });
 154     }
 155
 156     @Override
 157     public Mono<ServiceResult> editDataset(KnowledgeBase knowledgeBase, MaaSPlatform maaSPlatform) {
 158         KnowledgeBase knowledgeBaseRecordById = datasetMapper.getKnowledgeBaseRecordById(knowledgeBase.getKnowledgeBaseId());
 159         if (knowledgeBaseRecordById == null) {
 160             return Mono.just(new ServiceResult(new ResultHeader(500, "dataset is not exist")));
 161         }
 162         JSONObject updateParam = new JSONObject();
 163         updateParam.put("knowledge_id", knowledgeBase.getKnowledgeBaseId());
 164         updateParam.put("name", knowledgeBase.getKnowledgeBaseName());
 165         updateParam.put("description", knowledgeBase.getKnowledgeBaseDescription());
 166         updateParam.put("model", maaSPlatform.getVectorModel());
 167
 168         return webClient.put()
 169                 .uri(maaSPlatform.getServerIp() + BiShengConstant.DATASET_V2_URL)
 170                 .contentType(APPLICATION_JSON)
 171                 .bodyValue(updateParam)
 172                 .retrieve()
 173                 .bodyToMono(BiShengCreateDatasetResponse.class)
 174                 .flatMap(response -> {
 175                     if (response.getStatus_code() == 200) {
 176                         return Mono.fromRunnable(() -> {
 177                             knowledgeBase.setUpdateTime(TimeUtil.getNowTime());
 178                             datasetMapper.updateKnowledgeBase(knowledgeBase);
 179                         }).then(Mono.just(new ServiceResult(new ResultHeader(200, "update success"))));
 180                     } else {
 181                         return Mono.just(new ServiceResult(new ResultHeader(500, response.getStatus_message())));
 182                     }
 183                 })
 184                 .onErrorResume(e -> {
 185                     log.error("Error occurred while delete dataset: {}", e.getMessage());
 186                     return Mono.just(new ServiceResult(new ResultHeader(500, "update failed")));
 187                 });
 188     }
 189
 190     @Override
 191     public Mono<ServiceResult> uploadFiles(Flux<FilePart> fileParts, String knowledgeBaseId, String serverIp) {
 192         return fileParts.flatMap(filePart -> processFile(filePart, Integer.parseInt(knowledgeBaseId), serverIp))
 193                 .then(Mono.just(new ServiceResult(new ResultHeader(200, "upload success"))))
 194                 .onErrorResume(e -> {
 195                     log.error("Error occurred during file upload: {}", e.getMessage());
 196                     return Mono.just(new ServiceResult(new ResultHeader(500, "file upload failed")));
 197                 });
 198     }
 199
 200     @Override
 201     public Mono<ServiceResult> deleteFile(String fileId, String serverIp) {
 202         return webClient.delete()
 203                 .uri(serverIp + BiShengConstant.DELETE_FILE_URL + fileId)
 204                 .header(CommonConstant.COOKIE, BiShengConstant.COOKIE_VALUE)
 205                 .retrieve()
 206                 .bodyToMono(BiShengCreateDatasetResponse.class)
 207                 .flatMap(response -> {
 208                     if (response.getStatus_code() == 200) {
 209                         return Mono.fromRunnable(() -> datasetMapper.deleteFileByFileId(fileId)).then(Mono.just(new ServiceResult(new ResultHeader(200, "delete file success"))));
 210                     } else {
 211                         return Mono.just(new ServiceResult(new ResultHeader(response.getStatus_code(), response.getStatus_message())));
 212                     }
 213                 })
 214                 .onErrorResume(e -> {
 215                     log.error("Error occurred while delete dataset: {}", e.getMessage());
 216                     return Mono.just(new ServiceResult(new ResultHeader(500, "delete file failed")));
 217                 });
 218     }
 219 }