数据处理-创新实训

数据处理

文书数据预处理

定义了一个名为WenShuUtil的工具类，用于处理文书数据，包括从资源文件中读取文书信息、将其解析为Case对象，并将这些对象存储到Elasticsearch中。

package com.sprint.questai.util;

import cn.hutool.core.io.resource.ResourceUtil;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sprint.questai.model.entity.wenshu.Case;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
@Component
public class WenShuUtil {
    @Resource
    private ElasticsearchClient client;
    public  List<Case> parseCases(String wenshuid){
        String basicPath = "legal_data/wenshu/dev/";
        String path = basicPath + wenshuid;
        List<Case> cases = new ArrayList<>() ;
        ObjectMapper mapper = new ObjectMapper();
        try {
            JsonNode jsonNode = mapper.readTree(ResourceUtil.getStream(path));
            JsonNode ctxsNode = jsonNode.get("ctxs");
            if (!ctxsNode.isMissingNode()) {
                ctxsNode.fieldNames().forEachRemaining(key -> {
                    JsonNode caseNode = ctxsNode.get(key);
                    try {
                        Case aCase = mapper.treeToValue(caseNode, Case.class);

                        //System.out.println(aCase);
                        cases.add(aCase);
                    } catch (JsonProcessingException e) {
                        throw new RuntimeException(e);
                    }

                });


            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        return cases;
    }
    public void saveCasesToEs(List<Case> cases){
        for (Case aCase : cases) {
            try {
                client.index(i -> i.index("cases").id(aCase.getCaseId()).document(aCase));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
    //获取resource目录下path下的所有case

    public List<String> getWenShuFileNameByPath(String path){
        List<String> fileNames = new ArrayList<>();
// 创建File对象
        File folder = new File(path);

        // 获取文件夹下所有的文件和文件夹
        File[] files = folder.listFiles();
        // 检查files数组是否为空（即文件夹是否存在或非空）
        if (files != null) {
            for (File file : files) {
                // 如果只需要文件名，可以使用file.getName()
                // 如果需要完整路径，可以使用file.getAbsolutePath()
                fileNames.add(file.getName());
            }
        }

        // 打印出文件名列表
        //fileNames.forEach(System.out::println);
        return fileNames;
    }


}

法考数据预处理

从资源文件中读取法考信息并将其转换为FakaoInfo对象。

public List parseFakaoInfo()：定义一个公共方法，返回一个包含FakaoInfo对象的列表。

String basicPath = “legal_data/fakao/fakao_gpt4.json”;：定义JSON文件的路径。

List fakaoInfos = new ArrayList<>();：初始化一个空的FakaoInfo列表。

ObjectMapper mapper = new ObjectMapper();：创建一个ObjectMapper实例，用于处理JSON数据。

JsonNode jsonNode = mapper.readTree(ResourceUtil.getStream(basicPath));：读取JSON文件并解析为JsonNode对象。

for (JsonNode node : jsonNode)：遍历JSON数组的每个节点。

FakaoInfo fakaoInfo = mapper.treeToValue(node, FakaoInfo.class);：将JSON节点转换为FakaoInfo对象。

fakaoInfos.add(fakaoInfo);：将FakaoInfo对象添加到列表中。

return fakaoInfos;：返回包含所有FakaoInfo对象的列表。

package com.sprint.questai.util;

import cn.hutool.core.io.resource.ResourceUtil;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.sprint.questai.model.entity.fakao.FakaoInfo;
import org.elasticsearch.client.license.LicensesStatus;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

/**
* @Date: 2024/5/30 18:31
* @Description: 法考工具类，用于从resource中获取法考信息并加入向量数据库
  */

/**
* [
*  {
*   "input": "甲男与乙女于某日中午公开在某公园内发生性关系，引起游客的极大愤慨，造成恶劣的社会影响。对甲、乙的行为应如何认定?",
*   "output": "在分析甲男与乙女在公园内公开发生性关系的行为是否构成犯罪之前，我们需要明确相关法律规定。在中国法律体系中，可能涉及的罪名主要有“寻衅滋事罪”、“公然侮辱罪”和“猥亵罪”。\n\n首先，考虑是否构成“寻衅滋事罪”。根据《中华人民共和国刑法》第二百九十三条的规定，寻衅滋事罪是指寻衅滋事，扰乱公共秩序的行为。然而，甲男与乙女的行为虽然在公共场合发生，但其主要行为是两人之间的私人行为，没有直接目的去扰乱公共秩序或者寻找与他人的冲突，因此难以构成寻衅滋事罪。\n\n其次，考虑是否构成“公然侮辱罪”。根据《中华人民共和国刑法》第二百四十六条，公然侮辱他人，情节严重的，构成公然侮辱罪。甲男与乙女的行为虽然在公共场所进行，但其行为的对象并非特定的他人，而是两人之间的私人行为，因此不构成对他人的“公然侮辱”。\n\n再次，考虑是否构成“猥亵罪”。根据《中华人民共和国刑法》第二百三十七条，以暴力、胁迫手段或者其他方法强制猥亵他人或者侮辱妇女的，构成猥亵罪。甲男与乙女的性关系是公开且双方自愿的，不存在使用暴力、胁迫或其他方法的情形，因此不构成猥亵罪。\n\n最后，虽然甲男与乙女的行为在道德上可能受到公众的谴责，并且可能违反了公共场所的管理规定，但在刑法层面上，他们的行为不构成上述任何一种犯罪。因此，从法律的角度来看，甲男与乙女的行为应当被认定为“无罪”。\n\n综上所述，甲男与乙女在公园内公开发生性关系的行为，虽然可能违反了社会公德和公共场所的管理规定，但根据现行的《中华人民共和国刑法》的相关规定，他们的行为不构成任何犯罪，因此应当被认定为“无罪”。",
*   "type": "qingjing"
*  },
*  {
*   "input": "Question: 根据修订的刑诉法的规定，侦查机关询问证人不可在什么地点进行?\nA. 现场\nB. 证人所在单位或住处\nC. 证人本人提出的地点\nD. 侦查机关指定的地点",
*   "output": "分析：侦查机关在询问证人时，选择的地点应当保障证人的合法权益，同时也要考虑到调查的有效性和便利性。选项A“现场”是侦查机关进行询问的常见地点之一，因为现场可以帮助证人回忆事件的情况，有助于获取更准确的证词。选项B“证人所在单位或住处”考虑到了证人的便利和舒适度，有时在证人的生活或工作环境中进行询问，可以减少证人的紧张情绪，有助于获取真实的证词。选项C“证人本人提出的地点”体现了对证人意愿的尊重，只要该地点不影响询问的公正性和有效性，侦查机关通常会考虑证人的请求。\n\n选项D“侦查机关指定的地点”在实际操作中也是常见的，但根据修订的刑事诉讼法的规定，侦查机关应当尊重和保障证人的合法权益，避免对证人造成不必要的压力或影响其正常生活和工作。如果侦查机关无理由地限定特定的询问地点，可能会被视为对证益的不当，尤其是如果该地点给证人带来不便或压力。因此，虽然侦查机关有权指定询问地点，但这种指定应当基于案件的具体情况和证人的实际情况，不能随意指定。\n\n根据《中华人民共和国刑事诉讼法》的相关规定，侦查机关在询问证人时应当采取有利于保护证人合法权益的措施，避免对证人造成不必要的困扰。因此，选项D“侦查机关指定的地点”是不可随意进行的，需要考虑到证人的权益和案件的实际需要。因此，正确答案是D。",
*   "type": "gainian"
*  },
*  ]
   */
   @Component
   public class FakaoUtil {
   public List<FakaoInfo> parseFakaoInfo(){
   //read fakao info from resource
   String basicPath = "legal_data/fakao/fakao_gpt4.json";
   List<FakaoInfo> fakaoInfos = new ArrayList<>() ;
   ObjectMapper mapper = new ObjectMapper();
   try {
   JsonNode jsonNode = mapper.readTree(ResourceUtil.getStream(basicPath));
   for (JsonNode node : jsonNode) {
   FakaoInfo fakaoInfo = mapper.treeToValue(node, FakaoInfo.class);
   fakaoInfos.add(fakaoInfo);
   }

   } catch (IOException e) {
   throw new RuntimeException(e);
   }
   return fakaoInfos;

   }

   public static void main(String[] args) {
   FakaoUtil fakaoUtil = new FakaoUtil();
   List<FakaoInfo> fakaoInfos = fakaoUtil.parseFakaoInfo();
   for (FakaoInfo fakaoInfo : fakaoInfos) {
   System.out.println(fakaoInfo);
   }
   }
   }

法律文件分割与存储

/**
 * @Date: 2024-05-02
 *
 */
package com.sprint.questai.store;

import cn.hutool.core.io.file.FileReader;
import cn.hutool.core.io.resource.ResourceUtil;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.core.IndexResponse;

import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.indices.DeleteIndexRequest;
import com.sprint.questai.factory.ModelFactory;
import com.sprint.questai.model.entity.fakao.FakaoInfo;
import com.sprint.questai.model.entity.wenshu.Case;
import com.sprint.questai.model.enums.NameEnums;
import com.sprint.questai.module.store.Impl.ESEmbeddingService;
import com.sprint.questai.util.FakaoUtil;
import com.sprint.questai.util.WenShuUtil;
import dev.langchain4j.data.document.Document;
import dev.langchain4j.data.embedding.Embedding;
import dev.langchain4j.data.segment.TextSegment;
import dev.langchain4j.model.chat.ChatLanguageModel;
//import dev.langchain4j.model.embedding.BgeSmallZhQuantizedEmbeddingModel;
import dev.langchain4j.model.output.Response;
import dev.langchain4j.store.embedding.EmbeddingMatch;
import dev.langchain4j.store.embedding.EmbeddingStore;
import dev.langchain4j.store.embedding.EmbeddingStoreIngestor;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
//import javax.xml.soap.Text;
import java.io.IOException;
import java.net.URL;
import java.util.*;

@SpringBootTest
public class EsTest {
    @Resource
    private FakaoUtil fakaoUtil;
    @Resource
    private WenShuUtil wenShuUtil;
    @Resource
    private ElasticsearchClient client;
    @Resource
    private ESEmbeddingService embeddingService;
    @Resource
    private ModelFactory factory;
    //通用的embeddingModel
    
    @Test
    public void addCaseTest() throws IOException {
        Case aCase = new Case();
        aCase.setCaseId("123");
        //IndexResponse cases = client.index(i -> i.index("cases").id(aCase.getCaseId()).document(aCase));
        IndexResponse cases = client.index(i -> i.index("cases").id(aCase.getCaseId()).document(aCase));
        System.out.println(cases);
    }
    @Test
    public void search() throws IOException {
        Case aCase = new Case();
        //IndexResponse cases = client.index(i -> i.index("cases").id(aCase.getCaseId()).document(aCase));
        SearchResponse<Case> cases = client.search(s -> s.index("cases"), Case.class);
        System.out.println(cases);
    }

    @Test
    public void saveCasesToEsTest() {
        wenShuUtil.saveCasesToEs(wenShuUtil.parseCases("14501"));
    }

    @Test
    public void getFileNamesFromResource() {
        URL resource = ResourceUtil.getResource("legal_data/wenshu/dev");
        //从文件夹下获取所有文件名
        System.out.println(wenShuUtil.getWenShuFileNameByPath(resource.getPath()));
    }

    @Test
    public void addCaseEmbeddingTest() throws IOException {
        URL resource = ResourceUtil.getResource("legal_data/wenshu/dev");

        List<String> names = wenShuUtil.getWenShuFileNameByPath(resource.getPath());
        names = names.subList(1, 20);
        for (String s : names) {
            List<Case> cases = wenShuUtil.parseCases(s);
            embeddingService.saveCasesEmbedding(cases);
        }
//        //获取resource目录下legal_data/wenshu/dev下的所有case
//        List<Case> cases = wenShuUtil.parseCases("14501.json");
//        //获取10个case
//        //cases = cases.subList(0, 10);
//        embeddingService.saveCasesEmbedding(cases);
    }

    @Test
    public void addFakaoEmbeddingTest() {
        //获取resource目录下legal_data/fakao/fakao_gpt4.json下的所有法考信息
        List<FakaoInfo> fakaoInfos = fakaoUtil.parseFakaoInfo();
        //获取10个法考信息
        embeddingService.saveFakaoEmbedding(fakaoInfos);
    }
    @Test
    public void getCategory() {
        List<String> names = wenShuUtil.getWenShuFileNameByPath("D:\\Study\\Spring3\\chuangxin\\QuestAi\\quest-ai-backend\\src\\main\\resources\\legal_data\\wenshu\\dev");
        //names = names.subList(1, 20);
        Set<String> categories = new HashSet<>();
        for (String s : names) {
            List<Case> cases = wenShuUtil.parseCases(s);
            for (Case aCase : cases) {
                categories.add(aCase.getCategory().getCat1());
                categories.add(aCase.getCategory().getCat2());
                //System.out.println(aCase.getCategory());
            }
        }
        System.out.println(categories);

        System.out.println(categories.size());
    }

    @Test
    public void partialSaveCasesTest() throws IOException {
        URL resource = ResourceUtil.getResource("legal_data/wenshu/dev");
        String path = resource.getPath();
        List<String> names = wenShuUtil.getWenShuFileNameByPath(path);
        //names = names.subList(1, 20);
        for (String s : names) {
            List<Case> cases = wenShuUtil.parseCases(s);
            embeddingService.partialSaveCasesEmbedding(
                    cases,
                    NameEnums.JUDGE_ACCUSATION_NAME,
                    NameEnums.DEFAULT_EMBEDDING_MODEL,
                    NameEnums.ELASTIC_SEARCH_STORE);
        }
    }

    @Test
    public void searchCaseEmbeddingTest() {
        //case_record test
        Response<Embedding> response = embeddingService.embed("我设计的产品被其他人侵权使用");
        String indexName = NameEnums.generateEmbeddingIndexName(NameEnums.CASE_RECORD_NAME.toString(), NameEnums.DEFAULT_EMBEDDING_MODEL.toString());
        EmbeddingStore<TextSegment> store = factory.createEmbeddingStore(NameEnums.CASE_RECORD_NAME.toString(), NameEnums.DEFAULT_EMBEDDING_MODEL.toString(), NameEnums.ELASTIC_SEARCH_STORE.toString());
        List<EmbeddingMatch<TextSegment>> relevant = store.findRelevant(response.content(), 8, 0);

        for (EmbeddingMatch<TextSegment> emb : relevant) {
            System.out.println(emb);
        }
//        store = embeddingService.buildEmbeddingStore("judge_accusation");
//        relevant = store.findRelevant(response.content(), 5, 0);
//        for (EmbeddingMatch<TextSegment> emb : relevant) {
//            System.out.println(emb);
//        }
//
//        store = embeddingService.buildEmbeddingStore("judge_reason");
//        relevant = store.findRelevant(response.content(), 5, 0);
//        for (EmbeddingMatch<TextSegment> emb : relevant) {
//            System.out.println(emb);
//        }

    }
    @Test
    public void embeddingEnhenceTest(){
        //测试embedding增强
        String text = "我设计的产品被其他人侵权使用";
        ChatLanguageModel model = factory.createChatLanguageModel(NameEnums.CHAT_GLM_3_NAME.toString());
    }

    @Test
    public void searchCaseByMetaTest() {
        //case_record test
        Response<Embedding> response = embeddingService.embed("权益纠纷");
        EmbeddingStore<TextSegment> store = embeddingService.buildEmbeddingStore("case_record");
        List<EmbeddingMatch<TextSegment>> relevant = store.findRelevant(response.content(), 5, 0);

        for (EmbeddingMatch<TextSegment> emb : relevant) {
            System.out.println(emb);
        }

//        store = embeddingService.buildEmbeddingStore("judge_accusation");
//        relevant = store.findRelevant(response.content(), 5, 0);
//        for (EmbeddingMatch<TextSegment> emb : relevant) {
//            System.out.println(emb);
//        }
//
//        store = embeddingService.buildEmbeddingStore("judge_reason");
//        relevant = store.findRelevant(response.content(), 5, 0);
//        for (EmbeddingMatch<TextSegment> emb : relevant) {
//            System.out.println(emb);
//        }

    }

    @Test
    public void searchCaseByCaseIdTest() throws IOException {
        embeddingService.searchCaseByCaseId("9214edcf86e34265bba6adf200e5a827", "case_record");
        embeddingService.searchCaseByCaseId("9214edcf86e34265bba6adf200e5a827", "judge_accusation");
    }

    @Test
    public void getFileNamesTest() {
        System.out.println(wenShuUtil.getWenShuFileNameByPath("D:\\Study\\Spring3\\chuangxin\\QuestAi\\quest-ai-backend\\src\\main\\resources\\legal_data\\wenshu\\dev"));
    }

    @Test
    public void searchEmbeddingTest() {
        embeddingService.searchCaseByText(
                NameEnums.JUDGE_ACCUSATION_NAME.toString()
                , NameEnums.BGE_SMALL_ZH.toString(),
                "我未经博主小a允许私自使用了他花的画进行牟利",
                5);
    }

    @Test
    public void dashTest() {
//        EmbeddingModel embeddingModel = new BgeSmallZhQuantizedEmbeddingModel();
//        String api_key = System.getenv("DASHSCOPE_API_KEY");
//        //System.out.println(api_key);
//        DocumentSplitter spiltter = new DocumentBySentenceSplitter(150, 15);
//        //DocumentSplitter spiltter= DocumentSplitters.recursive(300, 15, tokenizer);
//        Document document = Document.from("原告陈某向本院提出诉讼请求：1、要求二被告返还彩礼60000元；2诉讼费由被告承担。事实和理由：原、被告经人介绍认识，2018年农历正月初六按农村风俗订婚，订婚时原告给被告礼金46054元。同年农历正月十三抄年命时原告家人又给被告彩礼金5620元。二人订婚后，原告就外出找工，被告在家打工，被告经常以买衣服、给其儿子买玩具、母亲过生日为由向原告索要财物共计20元。××××年××月××日，被告提出分手，称不愿与原告结婚。2018年8月21日，被告再次向原告提出分手，此后双方就彩礼事宜协商，但被告拒不返还。现诉至。\n" +
//                "被告毛某辩称，原告所述不属实，被告从来没有向原告索要过钱，原告诉称原、被告之间有矛盾是交往中正常存在的现象。诉称中关于订婚彩礼40000元属实，其他有关给付的钱系原告自愿给被告或家人的，被告一直都同意和原告结婚，是因为结婚前被告不送彩礼才没能结成婚，所以不愿意退还彩礼。\n" +
//                "被告刘某未向本院提交答辩状亦未进行口头答辩。\n" +
//                "本院经审理认定事实如下：原告陈某与被告毛某经人介绍认识，2018年农历正月初六双方按农村习俗举行了订婚仪式，原告方送给被告毛某彩礼礼金40000元，该款由被告毛某存放。后原、被告因琐事发生矛盾双方确定分手，因彩礼返还问题协商未果，诉至");
//        List<TextSegment> split = spiltter.split(document);
//        for (TextSegment textSegment : split) {
//            embeddingModel.embed(textSegment.text());
//            System.out.println(textSegment);
//        }

    }

    @Test
    void bgeEmbedTest() {
//        EmbeddingModel embeddingModel = new BgeSmallZhQuantizedEmbeddingModel();
//        Response<Embedding> response = embeddingModel.embed("原告陈某向本院提出诉讼请求：1、要求二被告返还彩礼60000元；2诉讼费由被告承担。事实和理由：原、被告经人介绍认识，2018年农历正月初六按农村风俗订婚，订婚时原告给被告礼金46054元。同年农历正月十三抄年命时原告家人又给被告彩礼金5620元。二人订婚后，原告就外出找工，被告在家打工，被告经常以买衣服、给其儿子买玩具、母亲过生日为由向原告索要财物共计20元。××××年××月××日，被告提出分手，称不愿与原告结婚。2018年8月21日，被告再次向原告提出分手，此后双方就彩礼事宜协商，但被告拒不返还。现诉至。\n" +
//                "被告毛某辩称，原告所述不属实，被告从来没有向原告索要过钱，原告诉称原、被告之间有矛盾是交往中正常存在的现象。诉称中关于订婚彩礼40000元属实，其他有关给付的钱系原告自愿给被告或家人的，被告一直都同意和原告结婚，是因为结婚前被告不送彩礼才没能结成婚，所以不愿意退还彩礼。\n" +
//                "被告刘某未向本院提交答辩状亦未进行口头答辩。\n" +
//                "本院经审理认定事实如下：原告陈某与被告毛某经人介绍认识，2018年农历正月初六双方按农村习俗举行了订婚仪式，原告方送给被告毛某彩礼礼金40000元，该款由被告毛某存放。后原、被告因琐事发生矛盾双方确定分手，因彩礼返还问题协商未果，诉至");
//        System.out.println(response.content().dimension());
    }

    List<String> splitDocument(String str){
        int i = 0;
        ArrayList<String> res = new ArrayList<>();
        while(i<str.length())
        {
            int j = i+7;
            while(j<str.length() && !shouldSplit(str,j)){
                j+=1;
            }
            res.add(str.substring(i,j));
            i = j;
        }
        return res;
    }

    boolean shouldSplit(String str,int j){
        int forward = 8;
        if(j+forward>=str.length()){
            return false;
        }
        if(str.charAt(j)!='第'){
            return false;
        }
        String sub = str.substring(j, j + forward);
        return sub.contains("第") && sub.contains("条");
    }

    @Test
    void saveLawTest() {
        EmbeddingStoreIngestor ingestor =factory.createEmbeddingStoreIngestor(
                NameEnums.LAW_NAME.toString(),
                NameEnums.DEFAULT_EMBEDDING_MODEL.toString(),
                NameEnums.ELASTIC_SEARCH_STORE.toString(),
                NameEnums.DEFAULT_DOCUMENT_SPLITTER.toString()
        );
        URL resource = ResourceUtil.getResource("legal_data/law/criminalLaw");
        FileReader fileReader = new FileReader(resource.getPath());
        String laws = fileReader.readString();
        ArrayList<String> lawsList = new ArrayList<>(Arrays.asList(laws.split("\r\n\r\n")));
        //String result = String.join("\n", lawsList);

          lawsList.removeIf(law -> law.isEmpty() || law.contains("节") || law.contains("编") || law.contains("章"));
        String result = String.join("\n", lawsList);
//        System.out.println(result);
        List<String> res = splitDocument(result);
        for (String re : res) {
            System.out.println(re);
//            ingestor.ingest(Document.from(re));
            System.out.println("=====================================");
        }
        //按行读取法律文件
        //将法律文件存入es

    }
    @Test
    void searchLaw() {

    }

    @Test
    void ingestorTest() {
        EmbeddingStoreIngestor ingestor =factory.createEmbeddingStoreIngestor(
                NameEnums.JUDGE_ACCUSATION_NAME.toString(),
                NameEnums.DEFAULT_EMBEDDING_MODEL.toString(),
                NameEnums.ELASTIC_SEARCH_STORE.toString(),
                NameEnums.DEFAULT_DOCUMENT_SPLITTER.toString()
        );
        Document document = Document.from("原告陈某向本院提出诉讼请求：1、要求二被告返还彩礼60000元；2诉讼费由被告承担。事实和理由：原、被告经人介绍认识，2018年农历正月初六按农村风俗订婚，订婚时原告给被告礼金46054元。同年农历正月十三抄年命时原告家人又给被告彩礼金5620元。二人订婚后，原告就外出找工，被告在家打工，被告经常以买衣服、给其儿子买玩具、母亲过生日为由向原告索要财物共计20元。××××年××月××日，被告提出分手，称不愿与原告结婚。2018年8月21日，被告再次向原告提出分手，此后双方就彩礼事宜协商，但被告拒不返还。现诉至。\n" +
                "被告毛某辩称，原告所述不属实，被告从来没有向原告索要过钱，原告诉称原、被告之间有矛盾是交往中正常存在的现象。诉称中关于订婚彩礼40000元属实，其他有关给付的钱系原告自愿给被告或家人的，被告一直都同意和原告结婚，是因为结婚前被告不送彩礼才没能结成婚，所以不愿意退还彩礼。\n" +
                "被告刘某未向本院提交答辩状亦未进行口头答辩。\n" +
                "本院经审理认定事实如下：原告陈某与被告毛某经人介绍认识，2018年农历正月初六双方按农村习俗举行了订婚仪式，原告方送给被告毛某彩礼礼金40000元，该款由被告毛某存放。后原、被告因琐事发生矛盾双方确定分手，因彩礼返还问题协商未果，诉至");
        ingestor.ingest(document);
    }

    @Test
    void clearIndex() throws IOException {
        //delete index
        client.indices().delete(DeleteIndexRequest.of(d -> d.index(NameEnums.JUDGE_ACCUSATION_BGE_INDEX.getText())));
    }

    public static void main(String[] args) {

    }
}