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