批量上传GPT知识库，前端elementui的upload上传组件，后端Golang的上传接口实现

为了实现批量上传GPT的知识库并且功能，那么这个上传组件就必不可少，需要能把文档上传到服务器中。

前端部分，我是采用的cdn引入的形式，引入的elmentui。该框架是有上传组件的，可以参考我的用法：

action部分就是上传接口，其他三个是上传之前的处理，上传成功和失败后的回调函数

                                <el-upload
                                        action="/{{.collectName}}/uploadDoc"
                                        :on-success="uploadDocSuccess"
                                        :on-error="uploadError"
                                        :before-upload="beforeUpload"
                                >
                                    <el-button type="primary" icon="el-icon-upload">上传 txt</el-button>
                                </el-upload>

上传之前，我对文件后缀进行了判断，只允许txt docx 和xlsx的后缀上传。并且增加了loading效果。

            //上传文件失败
            uploadDocSuccess(response, file, fileList){
                this.loading.close();
                if(response.code==200){
                    this.$message({
                        message: "上传成功",
                        type: 'success'
                    });
                    this.getAllKnowledge();
                }else{
                    this.$message({
                        message: response.msg,
                        type: 'error'
                    });
                }
            },
            //上传文件失败
            uploadError(){
                this.loading.close();
            },
            //上传之前
            beforeUpload(file){
                this.loading = this.$loading({
                    lock: true,
                    text: "上传中",
                });

                let ext=file.name.substring(file.name.lastIndexOf(".")+1);
                if (ext != 'txt' && ext != 'docx' && ext != 'xlsx') {
                    this.$message.error('上传文件只能是 .txt .docx .xlsx 格式!');
                    this.loading.close();
                    return false;
                }
            },

后端部分可以参照我的后端处理函数：

我在后端同样判断了后缀，并且是根据后缀的不同，来读取对应的文本。

然后再分块去调用向量化接口，存入向量数据库。

    //上传doc
    router.POST("/:collectName/uploadDoc", func(c *gin.Context) {
        collectName := c.Param("collectName")
        f, err := c.FormFile("file")
        if err != nil {
            c.JSON(200, gin.H{
                "code": 400,
                "msg":  "上传失败!" + err.Error(),
            })
            return
        } else {

            fileExt := strings.ToLower(path.Ext(f.Filename))
            if fileExt != ".docx" && fileExt != ".txt" && fileExt != ".xlsx" {
                c.JSON(200, gin.H{
                    "code": 400,
                    "msg":  "上传失败!只允许txt或docx或xlsx文件",
                })
                return
            }
            fileName := collectName + f.Filename
            c.SaveUploadedFile(f, fileName)
            text := ""
            if fileExt == ".txt" {
                // 打开txt文件
                file, _ := os.Open(fileName)
                // 一次性读取整个txt文件的内容
                txt, _ := ioutil.ReadAll(file)
                text = string(txt)
                file.Close()
            } else if fileExt == ".docx" {
                text, err = utils.ReadDocxAll(fileName)
            } else {
                text, err = utils.ReadExcelAll(fileName)
            }
            removeErr := os.Remove(fileName)
            if removeErr != nil {
                log.Println("Remove error:", fileName, removeErr)
            }
            if err != nil {
                c.JSON(200, gin.H{
                    "code": 400,
                    "msg":  err.Error(),
                })
                return
            }
            chunks := SplitTextByLength(text, 300)
            for _, chunk := range chunks {
                pointId := uuid.NewV4().String()
                Train(pointId, collectName, chunk)
            }
            os.Remove(fileName)
            c.JSON(200, gin.H{
                "code": 200,
            })
        }
    })