AICC - 在线客服SDK开发指南

1. 使用说明

欢迎使用 “AICC” 开发者工具套件（SDK）。SDK 对 API 接口调用进行了封装，让您不用复杂编程即可实现 “AICC” 与自有系统的集成，管理 “AICC” 的数据配置、呼叫控制、通话记录等各种资源。本项目已开源至GitHub： https://github.com/ti-net/clink-sdk。

2. 快速开始

2.1. 环境准备

和直接调用 API 接口一样，您也需要一个访问密钥：AccessKeyID/AccessKeySecret。
访问密钥对可以通过登录系统管理后台，在【系统管理-系统对接-接口密钥】模块自助生成。每个访问密钥对可以设置不同的接口访问控制权限。
目前，我们仅支持 Java 语言的 SDK，您需要一个基础的 Java 开发环境，JDK 版本 >= 1.6。

2.2. 安装 SDK

如果您使用 Apache Maven 来管理 Java 项目，只需在项目的 pom.xml 中文件加入相应的依赖项即可：

<dependency>
    <groupId>com.ti-net</groupId>
    <artifactId>clink-serversdk</artifactId>
    <version>3.0.30</version>
</dependency>

2.3. 使用 SDK

以下代码示例展示了使用 SDK 完成服务调用的 3 个主要步骤：

1.创建并初始化 Client 实例。
2.创建 API 请求并设置参数。
3.发起请求并处理应答或异常。

package com.tinet.clink.openapi;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.cc.request.queue.ListQueuesRequest;
import com.tinet.clink.cc.response.queue.ListQueuesResponse;

public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret
        /*
            设置请求平台：
                北京平台：api-bj.clink.cn
                上海平台：api-sh.clink.cn
            默认为北京平台
        */
        configuration.setHost("api-bj.clink.cn");

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        ListQueuesRequest request = new ListQueuesRequest();
        // 签名的有效时间（秒），最小值为 1，最大值为 86400（24 小时），默认为 5
        request.expires(5);
        request.setLimit(10);
        request.setOffset(0);

        // 发起请求并处理应答或异常
        ListQueuesResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response.getQueues()));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
    }
}

2.4. 错误处理

当服务端或者客户端出错时，SDK 会抛出相应的异常，其中会包含具体的错误信息，包括错误码（Error Code）和错误消息（Error Message）。您需要捕获这些异常，并根据错误信息进行相应的错误处理。SDK 的异常包括两种：

ServerException是服务端错误信息。
ClientException是SDK端错误信息。

以下代码示例展示了SDK的异常错误处理逻辑：

try {
      ListQueuesResponse response = client.getResponseModel(request);
      // 处理Response
      // ...
    } catch (ClientException e) {
      // 这里可以添加您自己的错误处理逻辑
      // 例如，打印具体的错误信息
      System.out.println("ErrorMessage=" + e.getErrMsg());
      // 如果遇上棘手问题，可以提交工单，并将RequestId提供给我们
      System.out.println("ResponseId=" + e.getRequestId());
    } catch (ServerException e) {
      // 这里可以添加您自己的错误处理逻辑
      // ...
    }

3. 会话管理

3.1. 访客发起会话

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatVisitorOpenSessionRequest;
import com.tinet.clink.livechat.response.ChatVisitorOpenSessionResponse;

public class ChatVisitorOpenSessionTest {

    public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                        "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatVisitorOpenSessionRequest request = new ChatVisitorOpenSessionRequest();
        request.setAppId("str");
        request.setCreateTime(System.currentTimeMillis());

        List<ChatMessageSyncModel> messages = new ArrayList<>();
        ChatMessageSyncModel chatMessageSyncModel = new ChatMessageSyncModel();
        chatMessageSyncModel.setSenderType(4);
        chatMessageSyncModel.setSenderId("str");
        chatMessageSyncModel.setSenderName("str");
        chatMessageSyncModel.setMessageType(5);
        chatMessageSyncModel.setContent("str");
        chatMessageSyncModel.setCreateTime(System.currentTimeMillis());
        messages.add(chatMessageSyncModel);

        request.setMessages(messages);
        ChatVisitorOpenSessionResponse response = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(response));
    }
}

3.2. 访客结束会话

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatVisitorCloseSessionRequest;
import com.tinet.clink.livechat.response.ChatVisitorCloseSessionResponse;

public class ChatVisitorCloseSessionTest {

    public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatVisitorCloseSessionRequest request = new ChatVisitorCloseSessionRequest();
        request.setSessionId("str");
        ChatVisitorCloseSessionResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

3.3. 访客完成满意度评价

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.model.ChatInvestigationOptionModel;
import com.tinet.clink.livechat.request.ChatSubmitInvestigationRequest;
import com.tinet.clink.livechat.response.ChatSubmitInvestigationResponse;

public class ChatSubmitInvestigationTest {

    public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatSubmitInvestigationRequest request = new ChatSubmitInvestigationRequest();
        request.setSessionId("str");

        ChatInvestigationOptionModel[] options = new ChatInvestigationOptionModel[1];
        options[0] = new ChatInvestigationOptionModel();
        options[0].setName("评价名称");
        String[] label = new String[2];
        label[0] = "标签1";
        label[1] = "标签2";
        options[0].setLabel(label);
        options[0].setStar(5);
        request.setOptions(options);

        request.setRemark("评价备注");

        request.setSolve(1);
        ChatSubmitInvestigationResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

3.4. 访客退出排队

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatQuitQueueRequest;
import com.tinet.clink.livechat.response.ChatQuitQueueResponse;

public class ChatQuitQueueTest {

    public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatQuitQueueRequest request = new ChatQuitQueueRequest();
        request.setSessionId("str");

        ChatQuitQueueResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

3.5. 访客转人工

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatRobotTransferRequest;
import com.tinet.clink.livechat.response.ChatRobotTransferResponse;

public class ChatRobotTransferTest {

    public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatRobotTransferRequest request = new ChatRobotTransferRequest();
        request.setSessionId("str");
        ChatRobotTransferResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

3.6. 发消息给客服

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatMessageToClientRequest;
import com.tinet.clink.livechat.response.ChatMessageToClientResponse;

public class ChatMessageToClientTest {

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatMessageToClientRequest request = new ChatMessageToClientRequest();
        request.setSessionId("str");
        request.setMessageType(1);
        request.setContent("str");
        request.setFileUrl("str");
        request.setFileName("str");
        //  request.setFile(new File("str"));
        ChatMessageToClientResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

3.7. 发消息给访客

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatMessageToVisitorRequest;
import com.tinet.clink.livechat.response.ChatMessageToVisitorResponse;

public class ChatMessageToVisitorTest {

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatMessageToVisitorRequest request = new ChatMessageToVisitorRequest();
        request.setCno("str");
        request.setSenderType(1);
        request.setSessionId("str");
        request.setMessageType(1);
        request.setContent("str");
        request.setFileUrl("");
        request.setFileName("str");
        //  request.setFile(new File("str"));
        ChatMessageToVisitorResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

4. 会话记录

4.1. 查询消息记录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import org.junit.Test;

public class ChatRecordTest extends AbstractTest {

    private ObjectMapper mapper = new ObjectMapper();

     public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ListChatMessageRequest request = new ListChatMessageRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client =  new Client(configuration);
        request.setLimit(10);
        request.setDate("20211020");
        request.setMainUniqueId("677586f3-c8a7-4e08-bfd4-8ba9e0be152c.1634632141");

        ChatMessageResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.2. 查询会话详情

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.livechat.request.ChatRecordInfoRequest;
import com.tinet.clink.livechat.response.ChatRecordResponse;

public class ChatRecordInfoTest extends AbstractTest {

    private ObjectMapper mapper = new ObjectMapper();

    public static void  main(String[] args) throws Exception {
        ChatRecordInfoRequest request = new ChatRecordInfoRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key>");

        Client client =  new Client(configuration);
        request.setMainUniqueId("20935007-dac8-4cb2-b67f-d5677baeebc0.1648108890");
        request.setDate("20220324");

        ChatRecordResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.3. 查询访客消息未读数

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.livechat.request.ChatVisitorInfoRequest;
import com.tinet.clink.livechat.response.ChatVisitorInfoResponse;

public class ChatVisitorInfoTest extends AbstractTest {

    private ObjectMapper mapper = new ObjectMapper();

    public static void  main(String[] args) throws Exception {
        ChatVisitorInfoRequest request = new ChatVisitorInfoRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key>");

        Client client =  new Client(configuration);
        request.setVisitorId("8609c4cf-fcf9-4efa-bc3d-02dc888a8443");
        request.setAccessId("ac89d543-30ff-4d15-b5c4-6e1a9cc80c25");

        ChatVisitorInfoResponse response = client.getResponseModel(request);
		System.out.println(response.getUnreadCount());
        System.out.println(mapper.writeValueAsString(response));

    }
}

4.4. 同步会话记录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatCommentRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.ChatInvestigationResponse;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class ChatRecordTest extends AbstractTest {

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ChatRecordRequest request = new ChatRecordRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        client = new Client(configuration);

        request.setLimit(10);
        request.setDate("20200727");

        ChatRecordResponse response = client.getResponseModel(request);
        System.out.println(response.getRecords().size());;
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.5. 同步消息记录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatCommentRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.ChatInvestigationResponse;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class ChatRecordTest extends AbstractTest {

    private ObjectMapper mapper = new ObjectMapper();

     public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ChatMessageRequest request = new ChatMessageRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client =  new Client(configuration);
        request.setLimit(10);
        request.setDate("20200730");

        ChatMessageResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.6. 同步会话详情记录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatCommentRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.ChatInvestigationResponse;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class ChatRecordTest extends AbstractTest {

    private ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ChatDetailRequest request = new ChatDetailRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setLimit(10);
        request.setDate("20200730");

        ChatDetailResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.7. 同步留言记录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatCommentRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.ChatInvestigationResponse;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class ChatRecordTest extends AbstractTest {

    private ObjectMapper mapper = new ObjectMapper();

   public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ChatCommentRequest request = new ChatCommentRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setLimit(10);
        request.setDate("20200730");

        ChatCommentResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.8. 同步满意度记录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatCommentRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.ChatInvestigationResponse;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class ChatRecordTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ChatInvestigationRequest request = new ChatInvestigationRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setLimit(10);
        request.setMainUniqueId("20935007-dac8-4cb2-b67f-d5677baeebc0.1648108890");
        request.setDate("20200730");

        ChatInvestigationResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.9. 查询聊天记录（新）

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.SessionMessageResponse;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class SessionRecordMessageTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        SessionMessageRequest request = new SessionMessageRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setMainUniqueId("84b40d1c-3be1-437e-a560-3ca30bb3fde6.1733397784");
        request.setPageIndex(2);
        request.setPageSize(1);

        SessionMessageResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.10. 查询会话详情（新）

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionInfoRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.SessionInfoResponse;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class SessionInfoTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        SessionInfoRequest request = new SessionInfoRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setMainUniqueId("84b40d1c-3be1-437e-a560-3ca30bb3fde6.1733397784");

        SessionInfoResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.11. 同步会话记录（新）

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionRecordRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.SessionInfoResponse;
import com.tinet.clink.livechat.response.SessionRecordResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class SessionRecordTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        SessionRecordRequest request = new SessionRecordRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setStartTime("2024-12-10 00:25");
        request.setEndTime("2024-12-10 10:25");
        request.setPageIndex(1);
        request.setPageSize(1);

        SessionRecordResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.12. 同步座席&机器人会话记录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionDetailRecordRequest;
import com.tinet.clink.livechat.request.ChatRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.SessionDetailRecordResponse;
import com.tinet.clink.livechat.response.SessionRecordResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class SessionDetailRecordTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        SessionDetailRecordRequest request = new SessionDetailRecordRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setStartTime("2024-12-10 00:25");
        request.setEndTime("2024-12-10 10:25");
        request.setPageIndex(1);
        request.setPageSize(1);

        SessionDetailRecordResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

4.13. 同步满意度记录（新）

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionDetailRecordRequest;
import com.tinet.clink.livechat.request.SessionInvestigationRecordRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.SessionInvestigationRecordResponse;
import com.tinet.clink.livechat.response.SessionRecordResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class SessionInvestigationRecordTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        SessionInvestigationRecordRequest request = new SessionInvestigationRecordRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setStartTime("2024-12-10 00:25");
        request.setEndTime("2024-12-10 10:25");
        request.setPageIndex(1);
        request.setPageSize(1);

        SessionInvestigationRecordResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

5. 报表

5.1. 座席工作量报表

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatChatClientWorkloadRequest;
import com.tinet.clink.livechat.response.StatChatClientWorkloadResponse;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatChatClientWorkloadRequest request = new StatChatClientWorkloadRequest();
        request.setDate("20201125");

        // 发起请求并处理应答或异常
        StatChatClientWorkloadResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response.getStatChatQueueWorkload()));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }  catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
    }
}

5.2. 队列报表

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatChatQueueWorkloadRequest;
import com.tinet.clink.livechat.response.StatChatQueueWorkloadResponse;

public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatChatQueueWorkloadRequest request = new StatChatQueueWorkloadRequest();
        request.setDate("20201125");

        // 发起请求并处理应答或异常
        StatChatQueueWorkloadResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response.getStatChatQueueWorkload()));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
    }
}

5.3. 座席工作台首页数据

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatChatClientWorkloadNewRequest;
import com.tinet.clink.livechat.response.StatChatClientWorkloadResponse;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatChatClientWorkloadNewRequest request = new StatChatClientWorkloadNewRequest();
        request.setDate("20220524");

        // 发起请求并处理应答或异常
        StatChatClientWorkloadResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response.getStatChatQueueWorkload()));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }  catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
    }
}

5.4. 座席工作考勤报表

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatChatClientWorkloadNewRequest;
import com.tinet.clink.livechat.response.StatChatClientWorkloadResponse;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatChatClientAttendanceRequest request = new StatChatClientAttendanceRequest();
        request.setStartTime("20220901");
        request.setEndTime("20220901");
        String[] strings = {"0001","0002"};
        request.setCnos(strings);
        request.setSortAsc(true);

        // 发起请求并处理应答或异常
        StatChatClientAttendanceResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response.getStatChatClientAttendance()));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        }  catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
    }
}

5.5. 座席工作质量报表

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.client.Client;
import com.tinet.clink.core.client.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatChatClientWorkQualityRequest;
import com.tinet.clink.livechat.response.StatChatClientWorkQualityResponse;
import java.util.ArrayList;
import java.util.List;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatChatClientWorkQualityRequest request = new StatChatClientWorkQualityRequest();
        request.setStartTime("2023-04-24 00:00");
        request.setEndTime("2023-04-24 23:59");
        List<String> cnos = new ArrayList<>();
        cnos.add("0001");
        cnos.add("0002");
        List<Integer> appType = new ArrayList<>();
        appType.add(1);
        appType.add(2);
        request.setAppType(appType);
        request.setCnos(cnos);
        request.setSortAsc(true);

        // 发起请求并处理应答或异常
        StatChatClientWorkQualityResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response.getStatChatClientWorkQuality()));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
	}
}

5.6. 座席工作量报表(新)

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.client.Client;
import com.tinet.clink.core.client.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatClientEffortRequest;
import com.tinet.clink.livechat.response.ChatClientEffortResponse;
import java.util.ArrayList;
import java.util.List;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        ChatClientEffortRequest request = new ChatClientEffortRequest();
        request.setStartTime("2023-04-24 00:00");
        request.setEndTime("2023-04-24 23:59");
        List<String> cnos = new ArrayList<>();
        cnos.add("0001");
        cnos.add("0002");
        request.setCnos(cnos);
        List<Integer> appType = new ArrayList<>();
        appType.add(1);
        appType.add(2);
        request.setAppType(appType);
        request.setSortAsc(true);
        request.setOffset(0);
        request.setLimit(10);
        // 发起请求并处理应答或异常
        ChatClientEffortResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
	}
}

5.7. 队列报表_按时间统计

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.client.Client;
import com.tinet.clink.core.client.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatQueuePeriodListRequest;
import com.tinet.clink.livechat.response.StatQueuePeriodListResponse;
import java.util.ArrayList;
import java.util.List;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatQueuePeriodListRequest request = new StatQueuePeriodListRequest();
        request.setStartTime("");
        request.setEndTime("");
        List<Integer> appType = new ArrayList<>();
        request.setAppType(appType);
        List<String> qnos = new ArrayList<>();
        request.setQnos(qnos);
        request.setPeriodType(1);
        // 发起请求并处理应答或异常
        StatQueuePeriodListResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
	}
}

5.8. 队列报表_按队列统计

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.client.Client;
import com.tinet.clink.core.client.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatQueueQnoPageRequest;
import com.tinet.clink.livechat.response.StatQueueQnoPageResponse;
import java.util.ArrayList;
import java.util.List;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatQueueQnoPageRequest request = new StatQueueQnoPageRequest();
        request.setStartTime("");
        request.setEndTime("");
        List<Integer> appType = new ArrayList<>();
        appType.add(1);
        request.setAppType(appType);
        List<String> qnos = new ArrayList<>();
        request.setQnos(qnos);
        request.setPageIndex(1);
        request.setPageSize(10);
        // 发起请求并处理应答或异常
        StatQueueQnoPageResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
	}
}

5.9. 满意度报表-按座席统计

package com.tinet.clink.core;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.client.Client;
import com.tinet.clink.core.client.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.StatInvestigationCnoPageRequest;
import com.tinet.clink.livechat.response.StatInvestigationCnoPageResponse;
import java.util.ArrayList;
import java.util.List;


public class Test {
    public static void main(String[] args) {
        // 创建访问服务的client实例并初始化
        ClientConfiguration configuration = new ClientConfiguration(
                "<your-access-key-id>",          // AccessKeyId
                "<your-access-key-secret>");     // AccessKeySecret

        Client client = new Client(configuration);

        // 创建API请求并设置参数
        StatInvestigationCnoPageRequest request = new StatInvestigationCnoPageRequest();
        request.setStartTime("");
        request.setEndTime("");
        List<Integer> appType = new ArrayList<>();
        request.setAppType(appType);
        List<String> cnos = new ArrayList<>();
        request.setCnos(cnos);
        List<String> qnos = new ArrayList<>();
        request.setQnos(qnos);
        request.setPageIndex(1);
        request.setPageSize(10);
        // 发起请求并处理应答或异常
        StatInvestigationCnoPageResponse response;
        ObjectMapper mapper = new ObjectMapper();

        try {
            response = client.getResponseModel(request);
            try {
                System.out.println(mapper.writeValueAsString(response));
            } catch (JsonProcessingException e) {
                e.printStackTrace();
            }
        } catch (ClientException e) {
            e.printStackTrace();
        } catch (ServerException e) {
            e.printStackTrace();
        }
	}
}

5.10. 满意度报表-按队列统计

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionDetailRecordRequest;
import com.tinet.clink.livechat.request.InvestigationStatQnoPageRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.InvestigationStatQnoPageResponse;
import com.tinet.clink.livechat.response.SessionRecordResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class InvestigationStatQnoTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        InvestigationStatQnoPageRequest request = new InvestigationStatQnoPageRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setStartTime("2024-12-10 00:25");
        request.setEndTime("2024-12-10 10:25");
        request.setPageIndex(1);
        request.setPageSize(1);

        InvestigationStatQnoPageResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

5.11. 会话量报表-按会话统计

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionDetailRecordRequest;
import com.tinet.clink.livechat.request.SessionStatPeriodRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.SessionDetailRecordResponse;
import com.tinet.clink.livechat.response.SessionStatPeriodResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class SessionStatPeriodTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        SessionStatPeriodRequest request = new SessionStatPeriodRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setStartTime("2024-12-10 00:25");
        request.setEndTime("2024-12-10 10:25");
        List<Integer> contactTypes = Collections.singletonList(1);
        request.setContactTypes(contactTypes);
        request.setPeriodType(1);

        SessionStatPeriodResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

5.12. 会话量报表_按接入号统计

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionDetailRecordRequest;
import com.tinet.clink.livechat.request.SessionStatPeriodRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.SessionStatAppResponse;
import com.tinet.clink.livechat.response.SessionRecordResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class SessionStatPeriodTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        SessionStatPeriodRequest request = new SessionStatPeriodRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setStartTime("2024-12-10 00:25");
        request.setEndTime("2024-12-10 23:25");
        request.setPageIndex(1);
        request.setPageSize(2);
        List<Integer> contactTypes = Collections.singletonList(1);
        request.setContactTypes(contactTypes);

        SessionStatAppResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

5.13. 座席工作量报表（新）

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionDetailRecordRequest;
import com.tinet.clink.livechat.request.ClientStatCnoPageRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.ClientStatCnoPageResponse;
import com.tinet.clink.livechat.response.SessionRecordResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class ClientStatCnoTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientStatCnoPageRequest request = new ClientStatCnoPageRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);
        request.setStartTime("2024-11-10 00:25");
        request.setEndTime("2024-12-10 10:25");
        request.setPageIndex(1);
        request.setPageSize(1);
        List<Integer> contactTypes = Collections.singletonList(1);
        request.setContactTypes(contactTypes);

        ClientStatCnoPageResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

5.14. 座席考勤报表（新）

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.SessionMessageRequest;
import com.tinet.clink.livechat.request.ChatDetailRequest;
import com.tinet.clink.livechat.request.ChatInvestigationRequest;
import com.tinet.clink.livechat.request.SessionDetailRecordRequest;
import com.tinet.clink.livechat.request.ClientStatAttendancePageRequest;
import com.tinet.clink.livechat.response.ChatCommentResponse;
import com.tinet.clink.livechat.response.ChatDetailResponse;
import com.tinet.clink.livechat.response.ClientStatAttendancePageResponse;
import com.tinet.clink.livechat.response.SessionRecordResponse;
import com.tinet.clink.livechat.response.ChatRecordResponse;
import org.junit.Test;

public class StatClientAttendanceTest extends AbstractTest {

    private static ObjectMapper mapper = new ObjectMapper();

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientStatAttendancePageRequest request = new ClientStatAttendancePageRequest();
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client = new Client(configuration);

        request.setStartTime("2024-12-09 00:25");
        request.setEndTime("2024-12-10 10:25");
        request.setPageIndex(1);
        request.setPageSize(1);
        List<Integer> contactTypes = Collections.singletonList(1);
        request.setContactTypes(contactTypes);

        ClientStatAttendancePageResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

6. 客服管理

6.1. 客服登录

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatClientLoginRequest;
import com.tinet.clink.livechat.response.ChatClientLoginResponse;

public class ChatClientLoginTest {

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatClientLoginRequest request = new ChatClientLoginRequest();
        request.setCno("str");
        request.setChatLoginStatus(1);
        request.setPauseType(1);
        request.setPauseDescription("str");
        ChatClientLoginResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

6.2. 客服登出

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatClientLogoutRequest;
import com.tinet.clink.livechat.response.ChatClientLogoutResponse;

public class ChatClientLogoutTest {

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatClientLogoutRequest request = new ChatClientLogoutRequest();
        request.setCno("str");
        ChatClientLogoutResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

6.3. 客服状态变更

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatClientStatusChangeRequest;
import com.tinet.clink.livechat.response.ChatClientStatusChangeResponse;

public class ChatClientStatusChangeTest {

    public static void main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatClientStatusChangeRequest request = new ChatClientStatusChangeRequest();
        request.setCno("str");
        request.setStatus(1);
        ChatClientStatusChangeResponse responseModel = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(responseModel));
    }
}

7. 监控

7.1. 查询在线客服队列座席状态

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.AbstractTest;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatMessageRequest;
import com.tinet.clink.livechat.response.ChatMessageResponse;
import org.junit.Test;import java.util.ArrayList;import java.util.Arrays;

public class ChatRecordTest extends AbstractTest {

    private ObjectMapper mapper = new ObjectMapper();

     public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");

        Client client =  new Client(configuration);

        ChatQueueStatusRequest request = new ChatQueueStatusRequest();
        // 查询所有队列注释此行
        request.setQnos(new ArrayList<>(Arrays.asList("2021","2019")));

        ChatQueueStatusResponse response = client.getResponseModel(request);
        System.out.println(mapper.writeValueAsString(response));
    }
}

8. 多商户

8.1. 网页接入号修改

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatWebSettingUpdateRequest;
import com.tinet.clink.livechat.response.ChatWebSettingUpdateResponse;

public class ChatWebSettingUpdateTest {

    public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                        "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatWebSettingUpdateRequest request = new ChatWebSettingUpdateRequest();
        request.setAccessId("接入号Id");
        request.setAccessName("接入号名称");
        ChatWindowsSetting windowsSetting = new ChatWindowsSetting();
        windowsSetting.setLogo("窗口图标图片地址");
        request.setWindowSetting(windowsSetting);

        ChatWebSettingUpdateResponse response = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(response));
    }
}

8.2. 网页接入号复制

package com.tinet.clink.core.chat;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tinet.clink.core.Client;
import com.tinet.clink.core.ClientConfiguration;
import com.tinet.clink.core.exceptions.ClientException;
import com.tinet.clink.core.exceptions.ServerException;
import com.tinet.clink.livechat.request.ChatWebSettingCopyRequest;
import com.tinet.clink.livechat.response.ChatWebSettingCopyResponse;

public class ChatWebSettingCopyTest {

    public static void  main(String[] args) throws ServerException, ClientException, JsonProcessingException {
        ClientConfiguration configuration = new ClientConfiguration("<your-access-key-id>",
                "<your-access-key-id>");
        Client client = new Client(configuration);

        ChatWebSettingCopyRequest request = new ChatWebSettingCopyRequest();
        request.setAccessId("接入号Id");

        ChatWebSettingCopyResponse response = client.getResponseModel(request);
        ObjectMapper mapper = new ObjectMapper();
        System.out.println(mapper.writeValueAsString(response));
    }
}