Java SymphonyClient类代码示例

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
private Chat createChat(SymphonyClient senderClient, SymphonyClient receiverClient) throws
        StreamsException,
        UsersClientException {
    Chat chat = new Chat();
    chat.setLocalUser(senderClient.getLocalUser());
    Set<SymUser> remoteUsers = new HashSet<>();

    //You need to add both users because you are using the same chat object for both sender and receiver.
    remoteUsers.add(receiverClient.getLocalUser());
    remoteUsers.add(senderClient.getLocalUser());
    chat.setRemoteUsers(remoteUsers);
    chat.setStream(senderClient.getStreamsClient().getStream(remoteUsers));

    receiverClient.getChatService().addChat(chat);
    return chat;
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public static void sendMessage(SymphonyClient client, Chat chat, String message)
        throws MessagesException {
    SymMessage messageSubmission = new SymMessage();
    messageSubmission.setMessageText(message);

    client.getChatService().addChat(chat);

    client.getMessageService().sendMessage(chat, messageSubmission);
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public static SymphonyClient getSymphonyClient(SymphonyClientConfig symphonyClientConfig) throws InitException, AuthenticationException {
    SymphonyClient symClient = SymphonyClientFactory.getClient(SymphonyClientFactory.TYPE.BASIC);
    String proxy = symphonyClientConfig.get("proxy.url");

    if (proxy == null) {
        symClient.init(symphonyClientConfig);
        return symClient;
    } else {
        ClientConfig clientConfig = new ClientConfig();
        clientConfig.connectorProvider(new ApacheConnectorProvider());
        clientConfig.property(ClientProperties.PROXY_URI, proxy);

        try {
            Client httpClient = CustomHttpClient.getClient(
                    symphonyClientConfig.get(SymphonyClientConfigID.USER_CERT_FILE),
                    symphonyClientConfig.get(SymphonyClientConfigID.USER_CERT_PASSWORD),
                    symphonyClientConfig.get(SymphonyClientConfigID.TRUSTSTORE_FILE),
                    symphonyClientConfig.get(SymphonyClientConfigID.TRUSTSTORE_PASSWORD),
                    clientConfig);
            symClient.init(httpClient, symphonyClientConfig);
            return symClient;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return symClient;
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public static void sendMessage(String message, SymMessage.Format type, Long userID, SymphonyClient symClient) {
    SymMessage userMessage = new SymMessage();
    userMessage.setFormat(type);
    userMessage.setMessage(message);

    UserIdList list = new UserIdList();
    list.add(userID);
    try {
        symClient.getMessagesClient().sendMessage(symClient.getStreamsClient().getStream(list), userMessage);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public static Chat getChat(Long userID, SymphonyClient symClient) {
    UserIdList list = new UserIdList();
    list.add(userID);
    Stream stream = null;
    try {
        stream = symClient.getStreamsClient().getStream(list);
    } catch (Exception e) {
        e.printStackTrace();
    }

    return symClient.getChatService().getChatByStream(stream.getId());
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public static void sendMessage(String message, SymMessage.Format type, String email, SymphonyClient symClient) {
    SymMessage userMessage = new SymMessage();
    userMessage.setFormat(type);
    userMessage.setMessage(message);

    try {
        symClient.getMessageService().sendMessage(email, userMessage);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
@Override
public void setSymphonyClient(SymphonyClient symphonyClient) {
    this.symClient = symphonyClient;

}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public SymphonyClient getSymClient() {
    return symClient;
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public AiResponder(SymphonyClient symClient) {
    this.symClient = symClient;
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
/**
 * Sends a message to a user
 *
 * @param message   the message received from the user
 * @param userID    the id of the user
 * @param symClient the org.org.symphonyoss.ai's sym client
 */

public void sendMessage(String message, Long userID, SymphonyClient symClient) {

    SymUser symUser = new SymUser();
    symUser.setId(userID);


    try {

        sendMessage(message, symClient.getStreamsClient().getStream(symUser), symClient);

    } catch (Exception e) {
        logger.error("Error sending message", e);
    }

}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public AiCommandListener(SymphonyClient symClient) {
    this.symClient = symClient;
    aiResponder = new AiResponder(symClient);
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
/**
 * A method that allows other classes to determine if a given message
 * matches a command in this command listener
 *
 * @param message   the message
 * @param symClient Symphony client
 * @return True if the message is a command
 */
@SuppressWarnings("unused")
public static boolean isCommand(SymMessage message, SymphonyClient symClient) {

    logger.debug("Received message for response.");

    MlMessageParser mlMessageParser;

    try {

        mlMessageParser = new MlMessageParser(symClient);
        mlMessageParser.parseMessage(message.getMessage());

        String[] chunks = mlMessageParser.getTextChunks();

        return chunks[0].charAt(0) == AiConstants.COMMAND;

    } catch (Exception e) {
        logger.error("Could not parse message {}", message.getMessage(), e);
    }

    return false;
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
@SuppressWarnings("unused")
public SymphonyClient getSymClient() {
    return symClient;
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public ConnectionsService(SymphonyClient symClient) {
    this.symClient = symClient;
    connectionsWorker = new ConnectionsWorker(symClient, this);
    symClient.getMessageService().addConnectionsEventListener(this);
    new Thread(connectionsWorker,"ConnectionsWorker: "+symClient.getName()).start();
}
 

import org.symphonyoss.client.SymphonyClient; //导入依赖的package包/类
public ConnectionsWorker(SymphonyClient symClient, ConnectionsListener connectionsListener) {
    this.symClient = symClient;
    this.connectionsListener = connectionsListener;

}