import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@Override
public boolean init(String botId, Map<String, String> configs, String[] channels) {
    logger = LogManager.getLogger(IrcBot.class.getSimpleName() + ":" + botId);

    if (!configs.containsKey(USERNAME_KEY))
        return false;
    if (!configs.containsKey(HOST_KEY))
        return false;

    client = Client.builder()
            .nick(configs.get(USERNAME_KEY))
            .serverHost(configs.get(HOST_KEY))
            .listenInput(line -> logger.debug("[I]: " + line))
            .listenOutput(line -> logger.debug("[O]: " + line))
            .listenException(logger::error)
            .defaultMessageMap(new SimpleDefaultMessageMap())
            .build();

    client.getEventManager().registerEventListener(this);
    this.botId = botId;
    this.configs = configs;
    this.channels = channels;

    return true;
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
/**
 * Builds the client for KICL. The client will be in the process of
 * connecting to the server when this method returns.
 *
 * @return the built client
 */
@Nonnull
private Client buildClient()
{
    final ClientBuilder builder = Client.builder();
    final String password = config.values().get("password").toString();

    builder.server(ConfigUtils.getString(config, "server"));
    builder.server(ConfigUtils.getInt(config, "port"));
    builder.nick(ConfigUtils.getString(config, "nick"));

    if (! password.isEmpty()) {
        builder.serverPassword(password);
    }

    return builder.build();
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
public void createBot()
{
    final ClientBuilder builder = Client.builder()
            .user(prop("login", prop("nick"))) // login, default to nick
            .server(prop("server")) // server
            .server(Integer.parseInt(prop("port", "6666"))) // port, default to 6666
            .nick(prop("nick")); // nick

    if (isPropSet("password")) builder.serverPassword(prop("password")); // server password



    bot = builder.build();
    bot.getEventManager().registerEventListener(new IRCListener(faxDater));
    if (isPropSet("channels"))
    {
        for (String c : prop("channels").split(","))
        {
            bot.addChannel("#" + c); // channels
        }
    }
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
public void sendNotifications(@NotNull final User requester, @NotNull final Channel channel, @NotNull final Client client) {
    Preconditions.checkNotNull(requester, "requester was null");
    Preconditions.checkNotNull(channel, "channel was null");
    Preconditions.checkNotNull(client, "client was null");
    final List<String> accountsInChannel = channel.getUsers().stream()
        .map(User::getAccount)
        .filter(Optional::isPresent)
        .map(Optional::get)
        .collect(Collectors.toList());
    this.getRegistrations().stream()
        .filter(r -> accountsInChannel.contains(r.getServicesAccount()))
        .filter(r -> r.hasOption(PingRegistrationOption.RECEIVE))
        .filter(r -> !r.getServicesAccount().equalsIgnoreCase(requester.getAccount().orElse(null)))
        .forEach(r -> {
            final boolean privmsg = r.hasOption(PingRegistrationOption.PRIVMSG);
            final Set<User> users = client.getChannels().stream().flatMap(ch -> ch.getUsers().stream()).distinct().filter(user -> r.getServicesAccount().equalsIgnoreCase(user.getAccount().orElse(null))).filter(account -> account != null).collect(Collectors.toSet());
            if (r.hasOption(PingRegistrationOption.PING_ALL_AUTHED_NICKS)) {
                users.forEach(user -> this.sendNotification(requester, channel, client, user.getNick(), privmsg));
            } else {
                users.stream().findFirst().ifPresent(user -> this.sendNotification(requester, channel, client, user.getNick(), privmsg));
            }
        });
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@ResponseBody
@RequestMapping(value = "/api/channel/{server}/{channel}", method = RequestMethod.GET, produces = APIHelper.PRODUCES)
public String apiViewChannel(@PathVariable String server, @PathVariable final String channel, final HttpServletResponse response) {
    final Client client = this.clientService.getFromHostname(server);
    final Channel c = this.channelService.getFromName(client, "#" + channel);
    if (c == null || !this.channelService.getAll(client).contains(c)) {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
        return APIHelper.makeError("No such channel.");
    }
    return APIHelper.makeJSON(jw -> {
        jw.array();
        for (final User user : c.getUsers()) {
            jw
                .object()
                .key("nickname")
                .value(user.getNick())
                .key("user")
                .value(user.getUserString())
                .key("hostname")
                .value(user.getHost())
                .endObject();
        }
        jw.endArray();
    });
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@ResponseBody
@RequestMapping(value = "/api/game/{server}/{channel}/{round}", method = RequestMethod.GET, produces = APIHelper.PRODUCES)
public String apiViewGameRound(@PathVariable String server, @PathVariable String channel, @PathVariable int round, final HttpServletResponse response) {
    final Client client = this.clientService.getFromHostname(server);
    final TheHumanityGame g = this.gameService.getFromChannelName(client, "#" + channel);
    if (g == null) {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
        return APIHelper.makeError("No such game");
    }
    try {
        return g.getPreviousRounds().get(round - 1).toJSON();
    } catch (final IndexOutOfBoundsException ex) {
        response.setStatus(HttpServletResponse.SC_NOT_FOUND);
        return APIHelper.makeError("No such round.");
    }
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
/**
 * Gets a raw ClientConfig object to retrieve Client settings from.
 *
 * @param client The Client to get settings for
 * @return The ClientConfig for the passed Client parameter
 */
public ClientConfig getConfig(Client client) {
    if (clientConfigs.containsKey(client)) {
        return clientConfigs.get(client);
    }
    return null;
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
/**
 * Builds a KittehIRCClientLib client and connects it.
 *
 * @param config ClientConfig this client gets its settings from
 * @return a connected Client
 */
public Client buildClient(ClientConfig config) {
    log.info("Connecting {} to {}", config.getBotNick(), config.getServerHost());

    Client.Builder clientBuilder = Client.builder().nick(config.getBotNick())
            .user(config.getBotIdent())
            .realName(config.getBotRealname())
            .serverHost(config.getServerHost())
            .serverPort(config.getServerPort())
            .secure(config.isServerSsl())
            .serverPassword(config.getServerPassword())
            .messageDelay(0);

    if (!config.isVerifySsl() && config.isServerSsl()) {
        log.warn("NOT VERIFYING SERVER SSL CERTIFICATE");
        log.warn("This is dangerous, consider adding the server certificate to your Java trust store instead.");
        clientBuilder.secureTrustManagerFactory(new AcceptingTrustManagerFactory());
    }

    Client client = clientBuilder.build();

    clientConfigs.put(client, config);
    client.getEventManager().registerEventListener(new MessageListener());
    client.getEventManager().registerEventListener(new ServerListener());
    config.getChannels().forEach(client::addChannel);
    return client;
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
public void sendNotification(@NotNull final User requester, @NotNull final Channel channel, @NotNull final Client client, @NotNull final String nickname, final boolean privmsg) {
    Preconditions.checkNotNull(requester, "requester was null");
    Preconditions.checkNotNull(channel, "channel was null");
    Preconditions.checkNotNull(client, "client was null");
    Preconditions.checkNotNull(nickname, "nickname was null");
    final String message = "Your presence has been requested by " + requester.getMessagingName() + " for a game of Cards Against Humanity in " + channel.getMessagingName() + ".";
    if (privmsg) {
        client.sendMessage(nickname, message);
    } else {
        client.sendNotice(nickname, message);
    }
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@Override
public TheHumanityGame getFromChannelName(@NotNull final Client client, @NotNull final String channel) {
    final Channel actualChannel = client.getChannel(channel).orElse(null);
    if (actualChannel == null) {
        return null;
    }
    return this.getFromChannel(actualChannel);
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@Nullable
@Override
public ServerInfo getServerInfo(@NotNull String hostname) {
    final Client client = this.clientService.getFromHostname(hostname);
    if (client == null) {
        return null;
    }
    return this.getServerInfo(client);
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@ResponseBody
@RequestMapping(value = "/api/channels/{server}", method = RequestMethod.GET, produces = APIHelper.PRODUCES)
public String apiViewAllChannels(@PathVariable String server, final HttpServletResponse response) {
    final Client client = this.clientService.getFromHostname(server);
    return APIHelper.makeObjectMapperJSON(
        response,
        om -> om.writeValueAsString(this.channelService.getAll(client).stream().map(Channel::getName).collect(Collectors.toSet()))
    );
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@RequestMapping(value = "/channel/{server}/{name}", method = RequestMethod.GET)
public String viewChannel(@PathVariable String server, @PathVariable String name, final Model model) {
    final Client client = this.clientService.getFromHostname(server);
    final Channel channel = this.channelService.getFromName(client, "#" + name);
    if (channel == null || !this.channelService.getAll(client).contains(channel)) {
        return "redirect:/";
    }
    model.addAttribute("channel", channel);
    return "channels/channel";
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@RequestMapping(value = "/game/{server}/{channel}", method = RequestMethod.GET)
public String gameInChannel(@PathVariable String server, @PathVariable String channel, final Model model) {
    final Client client = this.clientService.getFromHostname(server);
    final TheHumanityGame g = this.gameService.getFromChannelName(client, "#" + channel);
    if (g == null) {
        return "redirect:/";
    }
    model.addAttribute("game", g);
    return "games/game";
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
public ChannelListMessage(Client client) {
    this(client.getChannels().stream().map(Channel::getName));
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
public Application(int wsPort, String startupChannel, boolean debug, boolean ircSsl, boolean wsSsl, int ircPort,
                   String host, String username, String password, String nick, Set<String> userAccounts) {
    // TODO Nullcheck stuff
    ClientBuilder builder = Client.builder()
        .server(host)
        .server(ircPort)
        .listenException(Throwable::printStackTrace);

    if(nick != null) {
        builder
            .nick(nick)
            .realName(nick)
            .name(nick);
    }

    if(username != null) {
        builder.user(username);
    }

    if(password != null) {
        builder.serverPassword(password);
    }

    if(ircSsl) {
        builder.secure(true);
    }

    if(debug) {
        WebSocketImpl.DEBUG = true;
        builder
            .listenInput(i -> System.out.println("> " + i))
            .listenOutput(i -> System.out.println("< " + i));
    }

    client = builder.build();

    if(startupChannel != null) {
        client.addChannel(startupChannel);
    }

    client.getEventManager().registerEventListener(new EventManager(this, userAccounts));

    messageQueue = new LinkedBlockingQueue<>();
    server = new Server(this, messageQueue, wsPort, wsSsl);
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
public Client getClient() {
    return client;
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@Override
public Client getBot()
{
    return bot;
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@Override
public Set<TheHumanityGame> getAllForClient(@NotNull final Client client) {
    return this.humanity.getGameRegistrar().all().stream().filter(game -> client.getChannels().contains(game.getChannel())).collect(Collectors.toSet());
}
 

import org.kitteh.irc.client.library.Client; //导入依赖的package包/类
@NotNull
ServerInfo getServerInfo(@NotNull final Client client);