package com.qingxun.javasdkapi.examples;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.DocTransOpenApiClient;
import com.qingxun.javasdkapi.request.DownloadFileRequest;
import com.qingxun.javasdkapi.request.QueryTransProgressRequest;
import com.qingxun.javasdkapi.request.UploadTransRequest;
import com.qingxun.javasdkapi.response.DownloadFileResponse;
import com.qingxun.javasdkapi.response.QueryTransProgressResponse;
import com.qingxun.javasdkapi.response.UploadTransResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileNotFoundException;

/**
* 文档翻译
*/
public class DocTransOpenApiClientDemo extends CommonDemo {


private final static String uploadFilePath = "需要上传的文件路径";
private final static String appId = "您的appId";
private final static String privateKey = "您的privateKey";
private final static String fromLan = "文件的原语言";
private final static String toLan = "文件的目标语言";
private final static String saveTransDirPath = "保存翻译后的文件目录名称";
private final static String saveTransFileName = "保存翻译后的文件名称";
/**
    * 下载的文件类型(new):
    * 2：翻译后的pdf文件，支持格式：word、pdf、img。
    * 3：翻译后的word文件（支持格式：word、pdf）；ppt文件（支持格式：img、ppt）；excel文件（支持格式：excel）
    * 6：转换完成文档
    */
private final static Integer dType = 3;

private final static Logger log = LoggerFactory.getLogger(DocTransOpenApiClientDemo.class);

private static DocTransOpenApiClient docTransOpenApiClient = new DocTransOpenApiClient(appId, privateKey);


public static UploadTransResponse upload(String path) {
    File file = new File(path);
    UploadTransRequest uploadTransRequest = new UploadTransRequest.Builder()
            .setFrom(fromLan)
            .setTo(toLan).setFile(file)
            .builder();
    return docTransOpenApiClient.excute(uploadTransRequest);
}

public static QueryTransProgressResponse queryTransProgress(Integer docId) {
    QueryTransProgressRequest queryTransProgressRequest = new QueryTransProgressRequest.Builder().setTid(docId).builder();
    return docTransOpenApiClient.excute(queryTransProgressRequest);
}

public static DownloadFileResponse downloadFile(Integer docId, Integer dType) {
    DownloadFileRequest downloadFileRequest = new DownloadFileRequest.Builder().setTid(docId).setDtype(dType).builder();
    return docTransOpenApiClient.excute(downloadFileRequest);
}

public static void main(String[] args) throws FileNotFoundException, JsonProcessingException {
    ObjectMapper objectMapper = new ObjectMapper();
    QueryTransProgressResponse queryTransProgressResponse;
    UploadTransResponse uploadTransResponse = upload(uploadFilePath);
    log.info("文档翻译上传结果： {}",objectMapper.writeValueAsString(uploadTransResponse));
    if (uploadTransResponse != null && uploadTransResponse.getTid() > 0) {
        boolean flag = true;
        while (flag) {
            queryTransProgressResponse = queryTransProgress(uploadTransResponse.getTid());
            log.info("文档翻译查询进度： {}",objectMapper.writeValueAsString(queryTransProgressResponse));
            if (queryTransProgressResponse.getStatus().equals(314)) {
                //下载格式转换后的文件
                DownloadFileResponse response = downloadFile(queryTransProgressResponse.getTid(), dType);
                //保存格式转换后得到的文件
                bytesToFile(response.getBytes(), saveTransDirPath, saveTransFileName + response.getDocType());
                return;
            }
            if (queryTransProgressResponse.getStatus().equals(313)) {
                flag = true;
            } else {
                flag = false;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}
}
                                    

package com.qingxun.javasdkapi.examples;


import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.DocTransOpenApiClient;
import com.qingxun.javasdkapi.request.*;
import com.qingxun.javasdkapi.response.*;
import com.qingxun.javasdkapi.utils.HttpClientUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
* 文档翻译
*/
public class DocTransOpenApiClientDemo extends CommonDemo {


    private final static String uploadFilePath = "需要上传的文件路径";
    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String fromLan = "文件的原语言";
    private final static String toLan = "文件的目标语言";
    private final static String saveTransDirPath = "保存翻译后的文件目录名称";
    private final static String saveTransFileName = "保存翻译后的文件名称";
    //文件名称,传入文件流的时候必须传
    private final static String docName = "你的文件全名名称";

    /**
        * 下载的文件类型(new):
        * 2：翻译后的pdf文件，支持格式：word、pdf、img。
        * 3：翻译后的word文件（支持格式：word、pdf)；ppt文件（支持格式：img、ppt）；excel文件（支持格式：excel）
        * 6：转换完成文档
        */
    private final static Integer dType = 3;

    private final static Logger log = LoggerFactory.getLogger(DocTransOpenApiClientDemo.class);

    private static DocTransOpenApiClient docTransOpenApiClient = new DocTransOpenApiClient(appId, privateKey);

    //可以自定义请求接口的工具类使用更符合自己生产环境或者更高效的工具类，目前只支持传入文件流(FileStream)的方式而不是传入文件(file)的方式
    //private static DocTransOpenApiClient docTransOpenApiClient = new DocTransOpenApiClient(appId, privateKey,new HttpClientUtil());

    public static UploadTransResponse upload(String path) {
        UploadTransRequest uploadTransRequest = null;

            uploadTransRequest = new UploadTransRequest.Builder()
                    .setFrom(fromLan)
                    .setTo(toLan)
                    //传入文件或者文件流都可
                    .setFile(new File(path))
                    //.setFileStream(new FileInputStream(path)).setFileName(docName)
                    .builder();
        return docTransOpenApiClient.excute(uploadTransRequest);
    }

    public static QueryTransProgressResponse queryTransProgress(Integer docId) {
        QueryTransProgressRequest queryTransProgressRequest = new QueryTransProgressRequest.Builder().setTid(docId).builder();
        return docTransOpenApiClient.excute(queryTransProgressRequest);
    }

    public static DownloadFileResponse downloadFile(Integer docId, Integer dType) {
        DownloadFileRequest downloadFileRequest = new DownloadFileRequest.Builder().setTid(docId).setDtype(dType).builder();
        return docTransOpenApiClient.excute(downloadFileRequest);
    }

    public  static DetectDocPageResponse detected(String path) throws FileNotFoundException {
        DetectDocPageRequest detectDocPageRequest  = new DetectDocPageRequest.Builder()
                .setFileStream(new FileInputStream(path)).setFileName(docName)
                ////传入文件或者文件流都可
                //.setFile(new File(path))
                .builder();

        return docTransOpenApiClient.excute(detectDocPageRequest);
    }

    public static SubmitForDetectDocResponse submitForDetectDoc(Integer tid){
        SubmitForDetectDocRequest submitForDetectDocRequest = new SubmitForDetectDocRequest.Builder().setTid(tid)
                .setFrom(fromLan)
                .setTo(toLan).builder();
        return docTransOpenApiClient.excute(submitForDetectDocRequest);

    }

    public static void transForDeteDocPage() throws FileNotFoundException, JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        DetectDocPageResponse docPageResponse  = detected(uploadFilePath);
        QueryTransProgressResponse queryTransProgressResponse;
        log.info("文档上传上传结果： {}",objectMapper.writeValueAsString(docPageResponse));
        if (docPageResponse.getTid()!=null){
            SubmitForDetectDocResponse submitForDetectDocResponse = submitForDetectDoc(docPageResponse.getTid());
            log.info("文档翻译上传结果： {}",objectMapper.writeValueAsString(submitForDetectDocResponse));
            boolean flag = true;
            while (flag) {
                try {
                    queryTransProgressResponse = queryTransProgress(docPageResponse.getTid());
                    log.info("文档翻译查询进度： {}", objectMapper.writeValueAsString(queryTransProgressResponse));
                    if (queryTransProgressResponse.getStatus().equals(314)) {
                        //下载格式转换后的文件
                        DownloadFileResponse response = downloadFile(queryTransProgressResponse.getTid(), dType);
                        //保存格式转换后得到的文件
                        bytesToFile(response.getBytes(), saveTransDirPath, saveTransFileName + response.getDocType());
                        return;
                    }
                    if (queryTransProgressResponse.getStatus().equals(313)) {
                        flag = true;
                    } else {
                        flag = false;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        }

    }


    public   static void trans()throws FileNotFoundException, JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        QueryTransProgressResponse queryTransProgressResponse;
        UploadTransResponse uploadTransResponse = upload(uploadFilePath);
        log.info("文档翻译上传结果： {}",objectMapper.writeValueAsString(uploadTransResponse));
        if (uploadTransResponse != null && uploadTransResponse.getTid() > 0) {
            boolean flag = true;
            while (flag) {
                try {
                    queryTransProgressResponse = queryTransProgress(uploadTransResponse.getTid());
                    log.info("文档翻译查询进度： {}", objectMapper.writeValueAsString(queryTransProgressResponse));
                    if (queryTransProgressResponse.getStatus().equals(314)) {
                        //下载格式转换后的文件
                        DownloadFileResponse response = downloadFile(queryTransProgressResponse.getTid(), dType);
                        //保存格式转换后得到的文件
                        bytesToFile(response.getBytes(), saveTransDirPath, saveTransFileName + response.getDocType());
                        return;
                    }
                    if (queryTransProgressResponse.getStatus().equals(313)) {
                        flag = true;
                    } else {
                        flag = false;
                    }
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }

        }
    }


    public static void main(String[] args) throws FileNotFoundException, JsonProcessingException {
        trans();
        //transForDeteDocPage();
    }
}                 
                                    

package com.qingxun.javasdkapi.examples;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.TextTransOpenApiClient;
import com.qingxun.javasdkapi.request.TextTransRequest;
import com.qingxun.javasdkapi.response.TextTransResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 文字翻译
 */

public class TextTransOpenApiClientDemo {


    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String fromLan = "文字的原语言";
    private final static String toLan = "文字的目标语言";
    private final static String content="需要翻译的文字内容";

    private static TextTransOpenApiClient textTransOpenApiClient = new TextTransOpenApiClient(
            appId,privateKey);

    private static  final Logger log = LoggerFactory.getLogger(TextTransOpenApiClientDemo.class);
    private static  final ObjectMapper objectMapper = new ObjectMapper();

    public static TextTransResponse transText(String content){
        TextTransRequest transRequest = new TextTransRequest.Builder().setText(content)
                .setFrom(fromLan).setTo(toLan).builder();
        return textTransOpenApiClient.excute(transRequest);
    }


    public static void main(String[] args) throws JsonProcessingException {
        //文字翻译
        TextTransResponse response =  transText(content);
        log.info("文本翻译结果{}",objectMapper.writeValueAsString(response));
    }

}
                                    

package com.qingxun.javasdkapi.examples;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.DocConvertOpenApiClient;
import com.qingxun.javasdkapi.request.ConvertRequest;
import com.qingxun.javasdkapi.request.DownloadFileRequest;
import com.qingxun.javasdkapi.request.QueryTransProgressRequest;
import com.qingxun.javasdkapi.response.ConvertResponse;
import com.qingxun.javasdkapi.response.DownloadFileResponse;
import com.qingxun.javasdkapi.response.QueryTransProgressResponse;
import com.qingxun.javasdkapi.utils.HttpClientUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
* 格式转换
*/
public class DocConvertOpenApiClientDemo extends CommonDemo {

    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String convertFilePath = "需要格式转换的文件";
    private final static String saveConvertedDirPath = "保存转换后的文件目录名称";
    private final static String saveConvertedFileName = "保存转换后的文件名称";
    //转换的目标格式 -1:word;-3:excel;-6:pptx,-8:pdf,-9:ofd。
    private final static Integer conversionformat = -8;
    //文件名称,传入文件流的时候必须传
    private final static String docName = "你的文件全名名称";
    /**
    * 下载的文件类型(new):
    * 2：翻译后的pdf文件，支持格式：word、pdf、img。
    * 3：翻译后的word文件（支持格式：word、pdf)；ppt文件（支持格式：img、ppt）；excel文件（支持格式：excel）
    * 6：转换完成文档
    */
    private final static Integer dType =6;
    //源文件的语言（扫描件需设置语言）
    private final static  String fromLan="zh";

    private final static Logger log = LoggerFactory.getLogger(DocConvertOpenApiClientDemo.class);

    private final static ObjectMapper objectMapper = new ObjectMapper();

    private static DocConvertOpenApiClient docConvertOpenApiClient = new DocConvertOpenApiClient(appId, privateKey);

    //可以自定义请求接口的工具类使用更符合自己生产环境或者更高效的工具类，目前只支持传入文件流(FileStream)的方式而不是传入文件(file)的方式
    //private static DocConvertOpenApiClient docConvertOpenApiClient = new DocConvertOpenApiClient(appId, privateKey,new HttpClientUtil());

    public static ConvertResponse convertFile(String filePath) {
        ConvertRequest convertRequest = null;
        try {
            convertRequest = new ConvertRequest.Builder()
                    .setFile(new File(filePath))
                    //传入文件/文件流都可
                    //.setFileStream(new FileInputStream(filePath)).setFileName(docName)
                    .setFrom(fromLan)
                    .setConversionFormat(conversionformat)
                    .builder();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return docConvertOpenApiClient.excute(convertRequest);
    }

    public static QueryTransProgressResponse queryTransProcess(Integer tid) {
        QueryTransProgressRequest queryTransProgressRequest = new QueryTransProgressRequest.Builder().setTid(tid).builder();
        return docConvertOpenApiClient.excute(queryTransProgressRequest);
    }

    public static DownloadFileResponse downloadFile(Integer tid, Integer dtype) {
        DownloadFileRequest downloadFileRequest = new DownloadFileRequest.Builder().setTid(tid).setDtype(dtype).builder();
        return docConvertOpenApiClient.excute(downloadFileRequest);

    }


    public static void main(String[] args) throws JsonProcessingException {
        ConvertResponse convertResponse = convertFile(convertFilePath);
        log.info("转换文件结果{}", objectMapper.writeValueAsString(convertResponse));
        QueryTransProgressResponse queryTransProgressResponse;
        boolean flag = true;
        while (flag) {
            //查询格式转换后的转换进度
            queryTransProgressResponse = queryTransProcess(convertResponse.getTid());
            log.info("查询转换文件进度结果{}", objectMapper.writeValueAsString(queryTransProgressResponse));
            if (queryTransProgressResponse == null) {
                return;
            }
            if (queryTransProgressResponse.getStatus().equals(314)) {
                //下载格式转换后的文件
                DownloadFileResponse response = downloadFile(convertResponse.getTid(), dType);
                //保存格式转换后得到的文件
                bytesToFile(response.getBytes(), saveConvertedDirPath, saveConvertedFileName + response.getDocType());
                return;
            }
            if (queryTransProgressResponse.getStatus().equals(313)) {
                flag = true;
            } else {
                flag = false;
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}                         
                                    

package com.qingxun.javasdkapi.examples;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.ImageTransOpenApiClient;
import com.qingxun.javasdkapi.request.DownloadImageRequest;
import com.qingxun.javasdkapi.request.QueryTransImageProgressRequest;
import com.qingxun.javasdkapi.request.UploadTransImageRequest;
import com.qingxun.javasdkapi.response.DownloadImageResponse;
import com.qingxun.javasdkapi.response.QueryTransImageProgressResponse;
import com.qingxun.javasdkapi.response.UploadTransImageResponse;
import com.qingxun.javasdkapi.utils.HttpClientUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
* 图片翻译
*/
public class ImageTransOpenApiClientDemo extends CommonDemo {

    private final static String uploadFilePath = "需要翻译的图片路径";
    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String fromLan = "图片的原语言";
    private final static String toLan = "图片的目标语言";
    private final static String saveTransDirPath = "保存翻译后的文件目录名称";
    private final static String saveTransFileName = "保存翻译后的文件名称";
    // 文件名称,传入文件流的时候必须传
    private final static String docName = "你的文件全名名称";
    /**
    * 下载的文件类型(new):
    * 2：翻译后的pdf文件，支持格式：word、pdf、img。
    * 3：翻译后的word文件（支持格式：word、pdf)；ppt文件（支持格式：img、ppt）；excel文件（支持格式：excel）
    * 6：转换完成文档
    */
    private final static Integer dType = 3;
    //private final static String saveTransFileName = "保存翻译后的文件名称";


    private final static Logger log = LoggerFactory.getLogger(ImageTransOpenApiClientDemo.class);

    private static ImageTransOpenApiClient imageTransOpenApiClient = new ImageTransOpenApiClient(appId,privateKey);
    //也可以自定义请求接口的工具类使用更符合自己生产环境或者更高效的工具类，目前只支持传入文件流(FileStream)的方式而不是传入文件(file)的方式
    //private static ImageTransOpenApiClient imageTransOpenApiClient = new ImageTransOpenApiClient(appId,privateKey,new HttpClientUtil());

    public static DownloadImageResponse downloadFile(Integer tid) {
        DownloadImageRequest downloadFileRequest = new DownloadImageRequest.Builder()
                .setTid(tid).builder();

        return imageTransOpenApiClient.excute(downloadFileRequest);
    }

    public static  UploadTransImageResponse uploadImage(String filePath) throws FileNotFoundException {
        UploadTransImageRequest uploadTransImageRequest = new UploadTransImageRequest.Builder()
                //md5参数会自动计算
                //传入文件或者文件流都可
                //.setFileStream(new FileInputStream(filePath)).setFileName(docName)
                .setFile(new File(filePath))
                .setFrom(fromLan).setTo(toLan).builder();

        return imageTransOpenApiClient.excute(uploadTransImageRequest);
    }


    public static QueryTransImageProgressResponse queryTransImageProgress(Integer tid){
        QueryTransImageProgressRequest queryTransImageProgressRequest = new QueryTransImageProgressRequest.Builder().setTid(tid).builder();
        return imageTransOpenApiClient.excute(queryTransImageProgressRequest);
    }


    public static void main(String[] args) throws JsonProcessingException, FileNotFoundException {
        ObjectMapper objectMapper = new ObjectMapper();
        QueryTransImageProgressResponse queryTransProgressResponse;
        UploadTransImageResponse uploadTransResponse = uploadImage(uploadFilePath);
        log.info("图片翻译上传结果： {}",objectMapper.writeValueAsString(uploadTransResponse));
        if (uploadTransResponse != null && uploadTransResponse.getTid() > 0) {
            boolean flag = true;
            while (flag) {
                queryTransProgressResponse = queryTransImageProgress(uploadTransResponse.getTid());
                log.info("图片翻译查询进度： {}",objectMapper.writeValueAsString(queryTransProgressResponse));
                if (queryTransProgressResponse.getStatus().equals(0)) {
                    //下载图片翻译后的文件
                    DownloadImageResponse response = downloadFile(uploadTransResponse.getTid());
                    //保存图片翻译后得到的文件
                    bytesToFile(response.getBytes(), saveTransDirPath, saveTransFileName);
                    return;
                }
                if (queryTransProgressResponse.getStatus().equals(1)) {
                    flag = true;
                }
                if(queryTransProgressResponse.getStatus().equals(-1)) {
                    flag = false;
                }
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

    }
}               
                                    

package com.qingxun.javasdkapi.examples;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.ImageOcrOpenApiClient;
import com.qingxun.javasdkapi.request.OcrUploadTransRequest;
import com.qingxun.javasdkapi.response.OcrImageUploadResponse;
import com.qingxun.javasdkapi.utils.HttpClientUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
* OCR(图像识别）
*/
public class ImageOcrOpenApiClientDemo {


    private final static String uploadFilePath = "需要翻译的图片路径";
    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String fromLan = "图片的原语言";
    //文件名称,传入文件流的时候必须传
    private final static String docName = "你的文件全名名称";

    private final static Logger log = LoggerFactory.getLogger(ImageOcrOpenApiClientDemo.class);

    private final static ObjectMapper objectMapper = new ObjectMapper();

    private static ImageOcrOpenApiClient imageTransOpenApiClient = new ImageOcrOpenApiClient(
            appId, privateKey);

    //可以自定义请求接口的工具类使用更符合自己生产环境或者更高效的工具类，目前只支持传入文件流(FileStream)的方式而不是传入文件(file)的方式
    //private static ImageOcrOpenApiClient imageTransOpenApiClient = new ImageOcrOpenApiClient(appId, privateKey,new HttpClientUtil());


    public static OcrImageUploadResponse upload(String filePath) throws FileNotFoundException {
        OcrUploadTransRequest ocrUploadTransRequest = null;
            ocrUploadTransRequest = new OcrUploadTransRequest.Builder()
                    //传入文件或者文件流都可
                    .setFile(new File(filePath))
                    //.setFileStream(new FileInputStream(filePath)).setFileName(docName)
                    .setFrom(fromLan).builder();

        return imageTransOpenApiClient.excute(ocrUploadTransRequest);
    }


    public static void main(String[] args) throws JsonProcessingException, FileNotFoundException {
        OcrImageUploadResponse ocrImageUploadResponse = upload(uploadFilePath);
        log.info(objectMapper.writeValueAsString(ocrImageUploadResponse));
    }

}                                  
                                    

package com.qingxun.javasdkapi.examples;

import cn.hutool.core.util.ArrayUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.OnlineVoiceTransOpenApiClient;
import com.qingxun.javasdkapi.clients.OnlineVoiceTransWebSocketClient;
import com.qingxun.javasdkapi.request.OnlineVoiceGetConnecionIdRequest;
import com.qingxun.javasdkapi.request.OnlineVoiceGetDownloadUrlRequest;
import com.qingxun.javasdkapi.response.OnlineMsg;
import com.qingxun.javasdkapi.response.OnlineVoiceGetConnectionIdResponse;
import com.qingxun.javasdkapi.response.OnlineVoiceGetDownloadUrlResponse;
import org.apache.commons.lang3.StringUtils;
import org.java_websocket.handshake.ServerHandshake;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileInputStream;
import java.io.IOException;
import java.net.URISyntaxException;

/**
 * 语音识别翻译
 */
public class OnlineVoiceTransOpenApiClientDemo {

    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String fromLan = "语音的原语言";
    private final static String toLan = "语音的目标语言";

    private final static OnlineVoiceTransOpenApiClient onlineVoiceTransOpenApiClient = new OnlineVoiceTransOpenApiClient(appId, privateKey);

    private final static Logger log = LoggerFactory.getLogger(OnlineVoiceTransOpenApiClientDemo.class);

    private final static ObjectMapper objectMapper = new ObjectMapper();

    public static OnlineVoiceGetConnectionIdResponse getConnectionId() {
        OnlineVoiceGetConnecionIdRequest onlineVoiceGetConnecionIdRequest = new OnlineVoiceGetConnecionIdRequest.Builder().setFrom(fromLan)
                .setTo(toLan).builder();
        return onlineVoiceTransOpenApiClient.excute(onlineVoiceGetConnecionIdRequest);
    }

    public static OnlineVoiceGetDownloadUrlResponse getDownloadUrl(Integer recordId) {
        OnlineVoiceGetDownloadUrlRequest onlineVoiceGetDownloadUrlRequest = new OnlineVoiceGetDownloadUrlRequest.Builder().setRecordId(recordId).builder();
        return onlineVoiceTransOpenApiClient.excute(onlineVoiceGetDownloadUrlRequest);
    }


    //自定义在线语音处理逻辑
    static class OnlineHandler extends OnlineVoiceTransWebSocketClient.AbstractOnlineVoiceHandler {

        private Integer recordId;

        private String websocketUrl;

        public OnlineHandler(Integer recordId,String websocketUrl) {
            this.recordId = recordId;
            this.websocketUrl = websocketUrl;
        }

        @Override
        public void handMessage(OnlineMsg onlineMsg) {
            try {
                log.info("接收到内容{}",objectMapper.writeValueAsString(onlineMsg));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
            if (onlineMsg == null) {
                return;
            }
            if (onlineMsg.getState().equals("transing")) {
                if (onlineMsg.getMsgType() != null && onlineMsg.getMsgType() == 0) {
                    log.info("语音识别 原文:{}", onlineMsg.getTransMsg());
                }
                if (onlineMsg.getMsgType() != null && onlineMsg.getMsgType() == 1) {
                    log.info("语音识别 译文:{}", onlineMsg.getTransMsg());
                }
            }
            if (onlineMsg.getState().equals("receiveend")) {
                log.info("由于余额不足或者长时间未发送语音数据导致服务器拒绝接受在线语音数据");
            }
            if (onlineMsg.getState().equals("sucess")) {
                log.info("在线语音全部转写翻译成功");
                //下载译文音频
                OnlineVoiceGetDownloadUrlResponse onlineVoiceGetDownloadUrlResponse = getDownloadUrl(recordId);
                try {
                    log.info("译文音频的下载链接{}", objectMapper.writeValueAsString(onlineVoiceGetDownloadUrlResponse));
                } catch (JsonProcessingException e) {
                    e.printStackTrace();
                }

            }

        }

        @Override
        public void handleOpen(ServerHandshake serverHandshake) {
            log.info("{}连接成功",websocketUrl);

        }

        @Override
        public void handleClose(int i, String s, boolean b) {
            log.info("连接关闭{} {} {}",i,s,b);
        }

        @Override
        public void handleError(Exception e) {
            e.printStackTrace();

        }
    }

    public static void main(String[] args) throws URISyntaxException, IOException, InterruptedException {

        OnlineVoiceGetConnectionIdResponse response = getConnectionId();
        log.info("获取connectionId结果{}",objectMapper.writeValueAsString(response));
        if (null == response || response.getRecordId() == null || StringUtils.isEmpty(response.getConnectionId())) {
            log.error("获取connectionId失败");
        }
        String url = onlineVoiceTransOpenApiClient.getConnectionWebSocketUrl(response.getConnectionId());
        log.info("连接地址{}",url);
        OnlineHandler onlineHandler = new OnlineHandler(response.getRecordId(),url);
        //在线语音websocket连接
        OnlineVoiceTransWebSocketClient onlineVoiceTransWebSocketClient = new OnlineVoiceTransWebSocketClient(url, onlineHandler);
        onlineVoiceTransWebSocketClient.connect();
        //模拟发送在线语音
        FileInputStream inputStream = new FileInputStream("/Users/cedric/Downloads/test.wav");
        int bufferSize = 2560;
        byte[] b = new byte[bufferSize];
        int len;
        int all = 0;
        while (!onlineVoiceTransWebSocketClient.isOpen()) {
            Thread.sleep(1000);
        }
        try {
            while ((len = inputStream.read(b)) > 0) {
                all += 1;
                log.info("发送了{}字节,共发送{}次，需要发送{}次", len, all, (inputStream.available() / 2560));
                //发送语音数据
                onlineVoiceTransWebSocketClient.send(ArrayUtil.sub(b, 0, len));
            }
        } finally {
            if (inputStream != null) {
                inputStream.close();
            }
        }
        onlineVoiceTransWebSocketClient.send("{\"state\":\"recordend\",\"transMsg\":null,\"msgType\":null}");

        Thread.sleep(600000L);

    }


}
                                    

package com.qingxun.javasdkapi.examples;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.AudioTransOpenApiClient;
import com.qingxun.javasdkapi.request.AudioGetDownloadUrlRequest;
import com.qingxun.javasdkapi.request.AudioQueryProgressRequest;
import com.qingxun.javasdkapi.request.AudioUploadTransRequest;
import com.qingxun.javasdkapi.response.AudioGetDownloadUrlResponse;
import com.qingxun.javasdkapi.response.AudioQueryProcessResponse;
import com.qingxun.javasdkapi.response.AudioUploadTransResponse;
import com.qingxun.javasdkapi.utils.HttpClientUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

/**
* 音频识别翻译
*/
public class AudioTransOpenApiClientDemo {


    private final static String uploadFilePath = "需要上传的音频文件路径";
    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String fromLan = "音频文件的原语言";
    private final static String toLan = "音频文件的目标语言";
    //文件名称,传入文件流的时候必须传
    private final static String docName = "你的文件全名名称";

    private final static Logger log = LoggerFactory.getLogger(DocConvertOpenApiClientDemo.class);
    private final static ObjectMapper objectMapper = new ObjectMapper();


    private static AudioTransOpenApiClient audioTransOpenApiClient = new AudioTransOpenApiClient(appId, privateKey);

    //可以自定义请求接口的工具类使用更符合自己生产环境或者更高效的工具类，目前只支持传入文件流的方式而不是传入文件的方式
    //private static AudioTransOpenApiClient audioTransOpenApiClient = new AudioTransOpenApiClient(appId, privateKey,new HttpClientUtil());


    public static AudioUploadTransResponse uploadAudio(String filePath) throws FileNotFoundException {
        AudioUploadTransRequest audioUploadTransRequest = null;
        audioUploadTransRequest = new AudioUploadTransRequest.Builder()
                .setFrom(fromLan).setTo(toLan)
                //传入文件或者文件流都可
                //.setFile(new File(filePath))
                .setFileStream(new FileInputStream(filePath)).setFileName(docName)
                .builder();
        return audioTransOpenApiClient.excute(audioUploadTransRequest);
    }


    public static AudioQueryProcessResponse getTransProgress(Integer recordId) {
        AudioQueryProgressRequest audioUploadTransRequest = new AudioQueryProgressRequest.Builder().setRecordId(recordId).builder();
        return audioTransOpenApiClient.excute(audioUploadTransRequest);
    }


    public static AudioGetDownloadUrlResponse getDownloadUrl(Integer recordId) {
        AudioGetDownloadUrlRequest audioGetDownloadUrlRequest = new AudioGetDownloadUrlRequest.Builder().setRecordId(recordId).builder();
        return audioTransOpenApiClient.excute(audioGetDownloadUrlRequest);
    }


    public static void main(String[] args) throws JsonProcessingException, FileNotFoundException {
        //音频文件上传
        AudioUploadTransResponse audioUploadTransResponse = uploadAudio(uploadFilePath);
        if (audioUploadTransResponse != null && audioUploadTransResponse.getRecordId() > 0) {
            AudioQueryProcessResponse audioQueryProcessResponse = null;
            while (true) {
                //每三秒查询进度
                audioQueryProcessResponse = getTransProgress(audioUploadTransResponse.getRecordId());
                if (null == audioQueryProcessResponse) {
                    return;
                }
                log.info("查询进度结果{}", objectMapper.writeValueAsString(audioQueryProcessResponse));
                if (audioQueryProcessResponse.getStatus().equals("8")) {
                    AudioGetDownloadUrlResponse audioGetDownloadUrlResponse = getDownloadUrl(audioUploadTransResponse.getRecordId());
                    log.info("获取下载链接{}", objectMapper.writeValueAsString(audioGetDownloadUrlResponse));
                }
                try {
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

}                         
                                    

package com.qingxun.javasdkapi.examples;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.DictSearchOpenApiClient;
import com.qingxun.javasdkapi.request.DictSearchRequest;
import com.qingxun.javasdkapi.response.DictSearchResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


/**
 * 词典
 */
public class DictSearchOpenApiClientDemo {


    private final static String appId = "您的appId";
    private final static String privateKey = "您的privateKey";
    private final static String content = "需要搜索的文字内容";


    private static DictSearchOpenApiClient dictSearchOpenApiClient = new DictSearchOpenApiClient(
            appId, privateKey);

    private static final Logger log = LoggerFactory.getLogger(DictSearchOpenApiClientDemo.class);
    private static final ObjectMapper objectMapper = new ObjectMapper();

    public static DictSearchResponse dictSearch(String word) {
        DictSearchRequest dictRequest = new DictSearchRequest.Builder().setWord(word).builder();
        return dictSearchOpenApiClient.excute(dictRequest);
    }


    public static void main(String[] args) throws JsonProcessingException {
        //词典-词库搜索
        DictSearchResponse response = dictSearch(content);
        log.info("词库搜索结果{}", objectMapper.writeValueAsString(response));
    }

}
                                    

package com.qingxun.javasdkapi.examples;


import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.qingxun.javasdkapi.clients.AccountsOpenApiClient;
import com.qingxun.javasdkapi.request.GetAccountRequest;
import com.qingxun.javasdkapi.response.GetAccountResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 账户相关
 */
public class AccountsOpenApiClientDemo {

    private final static String appId = "您的appId";

    private final static String privateKey = "您的privateKey";

    /**
     * 资源包类型 1.文档翻译 2.文字翻译 3.图片翻译 4.格式转换
     */
    private final static Integer type=2;

    private final static Logger log = LoggerFactory.getLogger(DocConvertOpenApiClientDemo.class);

    private final static ObjectMapper objectMapper = new ObjectMapper();

    private static AccountsOpenApiClient accountsOpenApiClient = new AccountsOpenApiClient(appId, privateKey);

    public static GetAccountResponse getAccount(Integer type) {
        GetAccountRequest getAccountRequest = new GetAccountRequest.Builder()
                .setType(type)
                .builder();

        return accountsOpenApiClient.excute(getAccountRequest);
    }

    public static void main(String[] args) throws JsonProcessingException {
        //获取账户信息接口
        GetAccountResponse getAccountResponse = getAccount(type);
        log.info("获取账号信息{}",objectMapper.writeValueAsString(getAccountResponse));


    }
}
                                    

<?php
/**
 * 上传 
1.上传格式：pdf、Microsoft Office（doc、docx、dot、dotx、dotm、docm、xml、odt）、WPSOffice（wps、wpt）、xls、xlsx、et、ett、ppt、pptx、dps、dpt、txt、rtf；

2.上传文件最大50M（如有更高需求请联系销售）；

3. 不支持图纸、纯图片文档，加密文件请先去除密码；

4.翻译完成后按页从主账号里扣费；

5.目前普通账户支持一条翻译通道（即只能同时进行一个文件的上传翻译）,（如有更高需求请联系销售）；
 * uploadTranslate.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$filePath = __DIR__.'/file/1746-5354-8-1-53.pdf'; //文档路径

$params = [
    'from' => '文件的源语言',
    'to' => '文件的目标语言',
];

try {
    $result = $dispatch->uploadTranslate($params, $filePath);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}

                                    

<?php
/**
 * 上传文件检测页数
1.上传格式：pdf、Microsoft Office（doc、docx、dot、dotx、dotm、docm、xml、odt）、WPS Office（wps、wpt）、xls、xlsx、et、ett、ppt、pptx、dps、dpt、txt、rtf

2.上传文件最大50M（如有更高需求请联系销售）

3.不支持图纸、纯图片文档，加密文件请先去除密码

4.该功能需联系客服开通

调用说明：请求方式：post, file参数请以 multipart/form-data 方式的表单 POST 提交
 * detectDocPage.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$filePath = __DIR__.'/file/1746-5354-8-1-53.pdf'; //文档路径

$params = [
    'excelMode' => 0, // 0：只翻译当前打开sheet（默认），1：翻译全部sheet（页数按全部sheet字符数来计算）
];

try {
    $result = $dispatch->detectDocPage($filePath);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}


                                    

<?php
/**
* 检测页数文件提交翻译
* 同一个tid提交一次翻译即可。
* submitForDetectDoc.php
* Create on 2023/3/24 17:51
* Create by lihailiang@fanyigou.com
*/
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params = [
    'from' => '文件的源语言',
    'to' => '文件的目标语言',
    'tid' => '检测文档页数接口返回的tid', // 检测文档页数接口返回的tid
    'industryId' => '行业代码',
    'transImg' => '文档内图片翻译', // 0：不翻译文档内图片（默认），1：翻译文档内图片。目前支持中、英、日、韩的文档内图片翻译。（如有需要请联系销售开通）
    'bilingualControl' => '指定翻译模式' // 0：译文单独为一个文档（默认），1：双语对照（原文和译文在一个文档）
];

try {
    $result = $dispatch->submitForDetectDoc($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}                                        


                                    

<?php
/**
 * 获取进度
 * 提交任务完成后可调用此接口实时查询翻译、转换进度或检测页数进度
 * queryTransProgress.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params = [
    'tid' => '查询状态结果Id', // 查询状态结果Id
];

try {
    $result = $dispatch->queryTransProgress($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 下载
1.判断Response Headers 中 detectLanguage 的值，若存在且不为空即为自动检测出的语言（可能为多种语言），仅供参考
2.判断Response Headers 中Content-Type 的值，若包含"application/octet-stream" 则可直接进行下载，否则即为以下返回值
 * downloadFile.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params = [
    'tid' => '查询状态结果Id', // 查询状态结果Id
    'dtype' => '下载的文件类型',
//     下载的文件类型(new):
//      2：翻译后的pdf文件，支持格式：word、pdf、img。
//      3：翻译后的word文件（支持格式：word、pdf)；ppt文件（支持格式：img、ppt）；excel文件（支持格式：excel）
//      6：转换完成文档
];

try {
    $result = $dispatch->downloadFile($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}



                                    

<?php
/**
    * 文字翻译
1.待翻译文本字符长度不能超过2000；
2.语言方向：英、日、俄、韩、德、法、意 到中；中、日、俄、韩、德、法、意 到英
    * text.php
    * Create on 2023/3/24 17:51
    * Create by lihailiang@fanyigou.com
    */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params   = [
    'from' => '文件的源语言',
    'to' => '文件的目标语言',
    'text' => '待翻译文本，需UTF-8编码'
];

try {
    $result = $dispatch->text($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                        
                                    

<?php
/**
 * 文档转换
接口说明：用户调用接口进行 源文件上传，上传完成后会自动进行转换，通过tid可以查询转换的进度等数据。注意：

1.上传格式：pdf、doc、docx、ppt、pptx、xls、xlsx、hwp、caj、ofd

2.上传文件最大50M （如有更高需求请联系销售）

3.加密文件请先去除密码

4.转换完成后按页从主账号里扣费

调用说明：请求方式：post, file参数请以 multipart/form-data 方式的表单 POST 提交
 * convert.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$filePath = __DIR__.'/file/1746-5354-8-1-53.pdf'; //文档路径

$params = array(
    'from' => '扫描件需设置语言', // 扫描件需设置语言
    'conversionFormat' => -1 // 文档转换类型
//    转换的目标格式（目前支持pdf到其它格式的转换（excel,ppt,word,ofd），及其它格式（excel,ppt,word,hwp,caj,ofd）到pdf的转换） -1:word;-3:excel;-6:pptx,-8:pdf,-9:ofd。
);

try {
    $result = $dispatch->convert($params, $filePath);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 获取进度
 * 提交任务完成后可调用此接口实时查询翻译、转换进度或检测页数进度
 * queryTransProgress.php
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params = [
    'tid' => '查询状态结果Id', // 查询状态结果Id
];

try {
    $result = $dispatch->queryTransProgress($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 下载
1.判断Response Headers 中 detectLanguage 的值，若存在且不为空即为自动检测出的语言（可能为多种语言），仅供参考
2.判断Response Headers 中Content-Type 的值，若包含"application/octet-stream" 则可直接进行下载，否则即为以下返回值
 * downloadFile.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params = [
    'tid' => '查询状态结果Id', // 查询状态结果Id
    'dtype' => '下载的文件类型',
//     下载的文件类型(new):
//      2：翻译后的pdf文件，支持格式：word、pdf、img。
//      3：翻译后的word文件（支持格式：word、pdf)；ppt文件（支持格式：img、ppt）；excel文件（支持格式：excel）
//      6：转换完成文档
];

try {
    $result = $dispatch->downloadFile($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 图片上传
接口说明：用户调用接口进行 源文件上传，上传完成后会自动进行翻译，通过tid可以查询翻译的进度等数据。注意：
1.上传格式：jpg、jpeg、png、bmp
2.上传文件最大4M
3.支持15*15 - 2048*2048px尺寸内
4.翻译完成后按页从主账号里扣费
调用说明：请求方式：post, file参数请以 multipart/form-data 方式的表单 POST 提交
 * uploadTranslateImage.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$filePath = __DIR__.'/file/WechatIMG263.png'; //文档路径

$params = [
    'from' => '文件的源语言',
    'to' => '文件的目标语言',
];

try {
    $result = $dispatch->uploadTranslateImage($params, $filePath);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 图片翻译获取进度
 * queryImageTransProgress.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params = [
    'tid' => '查询状态结果Id', // 查询状态结果Id
];

try {
    $result = $dispatch->queryImageTransProgress($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}

                                    

<?php
/**
 * 图片翻译下载
 * 1.判断Response Headers 中Content-Type 的值，若包含"application/octet-stream" 则可直接进行下载，否则即为以下返回值
 * downloadImage.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params = [
    'tid' => '查询状态结果Id', // 查询状态结果Id
];

try {
    $result = $dispatch->downloadImage($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * OCR(图像识别)
接口说明：用户调用接口进行 源文件上传，上传完成后会自动进行识别并返回数据。注意：
1.上传格式：jpg、jpeg、png、bmp
2.上传文件最大4M
3.支持15*15 - 8192*8192px尺寸内
4.翻译完成后按次数从主账号里扣费
 * ocrUploadImage.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$filePath = __DIR__.'/file/WechatIMG263.png'; //文档路径

$params = [
    'from' => '文件的源语言',
];

try {
    $result = $dispatch->ocrUploadImage($params, $filePath);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 语音识别获取链接标识接口
 * getConnectionId.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params   = [
    'from' => '源语言（目前支持中文或者英文）',
    'to'   => '目标语言（目前支持英文或者中文）',
];

try {
    $result = $dispatch->getConnectionId($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 连接webscoket进行语音识别翻译
1.语音识别获取链接标识接口与当前的websocket传入的appid必须一致
2.connectionId的只有二十分钟有效期
3.connenctionId连接成功并发送音频数据后不能再使用当前connectionId进行二次连接
 * getTransAudioLink.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\WebSocket;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$connectionId = ''; // {connectionId}: 获取connectionId进行websocket连接，通过语音识别获取链接标识接口获取
$filePath = '音频路径';

// 初始化websocket连接
$socket = new WebSocket($appKey, $secKey);
$client = $socket->connection($connectionId);

// 模拟发送流式数据
send_data($client, $filePath, 6400);

function send_data($client, $path, $step)
{
    if (!file_exists($path)) {
        echo "file not exist";
        return;
    }
    $file = fopen($path, "r");
    // 发送消息的时间
    $pre_timestamp = return_mills_timestamp();
    while (!feof($file)) {
        $cur_timestamp = return_mills_timestamp();
        // 流式数据传输间隔推荐每6400bytes间隔200ms
        if ($cur_timestamp - $pre_timestamp < 200) {
            continue;
        }
        $pre_timestamp = $cur_timestamp;
        $buffer = fread($file, $step);
        send_binary_message($client, $buffer);
    }
    send_binary_message($client, "{\"end\": \"true\"}");
}

// 获取毫秒级时间戳
function return_mills_timestamp(): float
{
    $micrometer = microtime(true);
    return round($micrometer * 1000);
}


function send_binary_message($client, $message)
{
    $binary = pack("H*", bin2hex($message));
    $client->binary($binary);
    echo 'send binary message length: ' . strlen($binary) . "\n";
}
                                    

<?php
/**
 * 获取译文音频链接接口
 * getTransAudioLink.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params   = [
    'recordId' => '音频文件翻译id',
];

try {
    $result = $dispatch->getTransAudioLink($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}


                                    

<?php
/**
 * 音频文件上传接口
请求方式：post（file参数请以 multipart/form-data 方式的表单 POST 提交）
语音识别翻译支持音频格式：
1.pcm（pcm_s16le）、wav音频格式文件；
2.文件大小仅支持10min、10M以内文件；
3.采样率为16000，比特率为16bit；
4.单声道；
 * voiceAudioUpload.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$voicePath = __DIR__.'/file/test.wav'; //文档路径

$params = [
    'from' => '源语言（目前支持中文或者英文）',
    'to' => '目标语言（目前支持英文或者中文）',
];

try {
    $result = $dispatch->voiceAudioUpload($params, $voicePath);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 音频翻译任务查询接口
 * voiceAudioQueryProgress.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params   = [
    'recordId' => '音频文件翻译id',
];

try {
    $result = $dispatch->voiceAudioQueryProgress($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 音频下载译文链接接口
 * voiceAudioDownload.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params   = [
    'recordId' => '音频文件翻译id',
];

try {
    $result = $dispatch->voiceAudioDownload($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
 * 词典
 * dictSearch.php
 * Create on 2023/3/24 17:51
 * Create by lihailiang@fanyigou.com
 */
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params   = [
    'word' => '搜索词', // 词语，小于等于15个字符
];

try {
    $result = $dispatch->dictSearch($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}
                                    

<?php
/**
* 获取账户信息
* getAccount.php
* Create on 2023/3/24 17:51
* Create by lihailiang@fanyigou.com
*/
include_once __DIR__.'/../vendor/autoload.php';

use Fanyigou\ApiSdkPhp\Dispatch;
use Fanyigou\ApiSdkPhp\DispatchException;

$appKey = '您的应用ID';
$secKey = '您的密钥';

$dispatch = new Dispatch(['app_key' => $appKey, 'sec_key' => $secKey]);

$params   = [
    'type' => 1, //资源包类型 1.文档翻译 2.文字翻译 3.图片翻译 4.格式转换
];

try {
    $result = $dispatch->getAccount($params);
    print_r($result);
} catch (DispatchException $e) {
    print_r($e->getMessage());
}                                        
                                    

#引用api库
import TranslateApi

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
fromLang = "源语言"
toLang = "目标语言"
filepath = "本机上需要上传翻译的文件地址"
filename = "给上传的文件取一个名字吧"

#调用需要的方法（当前按方法是上传并翻译接口）
uploadTranslateres = TranslateApi.document_translation.uploadTranslate(ip, appid, privatekey, fromLang, toLang, filepath, filename)

#文档上传有四个追加参数
# industryId   行业代码   int    见行业列表  否
# transImg 文档内图片翻译    int    0：不翻译文档内图片（默认），1：翻译文档内图片。目前支持中、英、日、韩的文档内图片翻译。（如有需要请联系销售开通） 否
# excelMode    指定excel翻译模式    int    0：只翻译当前打开sheet（默认），1：翻译全部sheet（页数按全部sheet字符数来计算）   否
# bilingualControl 指定翻译模式 int    0：译文单独为一个文档（默认），1：双语对照（原文和译文在一个文档） 否
# 可以在参数后边用（industryId = 0 ,transImg=0 , excelMode = 0,bilingualControl=0）进行追加

# 追加示例（详情参数请查看开放平台）
res = TranslateApi.document_translation.uploadTranslate(fromLang,toLang,filepath,filename,industryId = 0 ,transImg=0 , excelMode = 0,bilingualControl=0)

#打印结果
print(res)

# 返回示例
# {'msg': '请求成功', 'code': 100, 'data': {'tid': tid}}
# 查询进度接口
# res = qxkjapi.queryTransProgress("tid")
# 文档下载接口
# res = qxkjapi.downloadFile("tid","3")

# 参数详情请查看开放平台文档
"http://open.qingxun.com/filecore.html"

                                    

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
fromLang = "源语言"
toLang = "目标语言"
filepath = "本机上需要上传翻译的文件地址"
filename = "给上传的文件取一个名字吧"
                                    

from TranslateApi.document_translation import uploadTranslate

uploadTranslateres = uploadTranslate(ip,appid,privatekey, fromLang, toLang, filepath, filename)
                                    

from TranslateApi.document_translation import queryTransProgress

tid = "调用uploadTranslate获取的tid"
queryTransProgressres = queryTransProgress(ip,appid,privatekey, tid)
                                    

from TranslateApi.document_translation import downloadFile

dtype = "下载的文件类型(new)"
Filecontent = downloadFile(ip,appid,privatekey,tid, dtype)
with open("保存文件地址","wb") as w:
    w.write(Filecontent)
                                    

from TranslateApi.text_trans import trans

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"

fromLang = "源语言"
toLang = "目标语言"
text = "要翻译的文字"
print(trans(ip,appid,privatekey,fromLang,toLang,text))
                                    

from TranslateApi.doc_convert import convert

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
filepath = "本机上需要上传翻译的文件地址"
filename = "给上传的文件取一个名字吧"
conversionFormat = "转换的目标格式(int类型)"

convertres = convert(ip,appid,privatekey,filepath,filename,conversionFormat)
print(convertres.json())
                                    

from TranslateApi.document_translation import queryTransProgress

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
tid = "调用convert获取的tid"

queryTransProgressres = queryTransProgress(ip,appid,privatekey, tid)
                                    

from TranslateApi.document_translation import downloadFile
    
ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
#6：转换完成文档
dtype = 6 
Filecontent = downloadFile(ip,appid,privatekey,tid, dtype)
with open("保存文件地址","wb") as w:
w.write(Filecontent)
                                    

from TranslateApi.image_trans import uploadTranslateImage

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"

fromLang = "源语言"
toLang = "目标语言"
filepath = "本机上需要上传翻译的文件地址"
filename = "给上传的文件取一个名字吧"

uploadTranslateImageres = uploadTranslateImage(ip,appid,privatekey,fromLang,toLang,filepath,filename)
print(uploadTranslateImageres)
                                    

from TranslateApi.image_trans import queryImageTransProgress

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
tid =  "调用uploadTranslateImage获取的tid"

queryImageTransProgressres = queryImageTransProgress(ip,appid,privatekey,tid)
print(queryImageTransProgressres)
                                    

from TranslateApi.image_trans import downloadImage
ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
tid = "调用uploadTranslateImage获取的tid"
Imagecontent = downloadImage(ip,appid,privatekey,tid)

with open("保存文件地址","wb") as w:
w.write(Imagecontent)
                                    

from TranslateApi.ocr import ocrUploadImage

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
fromLang = "源语言"
filepath = "本机上需要上传翻译的文件地址"
filename = "给上传的文件取一个名字吧"

ocrUploadImageres = ocrUploadImage(ip, appid,privatekey, fromLang, filepath, filename)
print(ocrUploadImageres)
                                    

from TranslateApi.voice_trans import getConnectionId

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
fromLang = "源语言"
toLang = "目标语言"

getConnectionIdres = getConnectionId(ip,appid,privatekey,fromLang,toLang)
print(getConnectionIdres)
                                    

from TranslateApi.voice_trans import up_webscoket

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
filepath = "本机上需要上传翻译的文件地址"
connectionId = "调用getConnectionId接口获取id"

up_webscoketres = up_webscoket(ip,appid,privatekey,filepath,connectionId)
print(up_webscoketres)
                                    

from TranslateApi.voice_trans import up_webscoket

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
filepath = "本机上需要上传翻译的文件地址"
connectionId = "调用getConnectionId接口获取id"

up_webscoketres = up_webscoket(ip,appid,privatekey,filepath,connectionId)
print(up_webscoketres)
                                    

from TranslateApi.audio_trans import audio_upload

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
fromLang = "源语言"
toLang = "目标语言"
filepath = "本机上需要上传翻译的文件地址"

audio_uploadres = audio_upload(ip,appid,privatekey,fromLang,toLang,filepath)
print(audio_uploadres.json())
                                    

from TranslateApi.audio_trans import audio_queryProgress
ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
recordId = "调用音频文件上传接口audio_upload获取"

audio_queryProgressres = audio_queryProgress(ip,appid,privatekey,recordId)
print(audio_queryProgressres.json())
                                    

from TranslateApi.audio_trans import audio_download
ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
recordId = "调用音频文件上传接口audio_upload获取"
audio_downloadres = audio_download(ip,appid,privatekey,recordId)
print(audio_downloadres.json())
                                    

from TranslateApi.dict_search import findDict

ip = "服务ip 如 www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
word = "搜索词"

findDictres = findDict(ip,appid,privatekey,word)
print(findDictres.json())
                                    

from TranslateApi.account import getAccount

ip = "www.fanyigou.com"
appid = "应用ID"
privatekey = "密钥"
Accountres = getAccount(ip,appid,privatekey)
print(Accountres.json())