essential-actions

[Twitch] - Add Better help link master

Download Browse

+16 −15

Author

Debayan Sutradhar (rnayabed) 2021-06-30 13:35

Committer

Debayan Sutradhar (rnayabed) 2021-06-30 13:35

Hash ae6ac823a2934fc077194249ddffa5f6a3b11705

Parent 98d273453fa64e7763d19c2e5958f6527bc1720b

Reference git #essential-actions/ae6ac823a2934fc077194249ddffa5f6a3b11705

Modified Files

List

Side by side diff

Inline diff

M twitch/add-stream-marker/src/main/java/addstreammarker/AddStreamMarkerAction.java

+1 −1

package addstreammarker;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class AddStreamMarkerAction extends NormalAction

{

private final String channelNameKey = "channel_name_asm";

private final String descriptionKey = "description_asm";

private Twirk twirk;

public AddStreamMarkerAction()

{

setName("Add stream marker");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

Property description = new Property(descriptionKey, Type.STRING);

description.setDisplayName("Description (Optional, max 140 chars)");

addClientProperties(channelName, description);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

final String description = getClientProperties().getSingleProperty(descriptionKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

if (description != null && !description.isEmpty()) {

twirk.channelMessage(String.format("/marker %s", description));

} else {

twirk.channelMessage("/marker");

}

} catch (Exception ex)

{

throw new MinorException(

"Failed to add marker to stream\nCould not add stream marker, please try again."

);

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

}

catch (Exception ex)

{

throw new MinorException("Twitch connection error - Please try again.");

}

M twitch/clear-chat/src/main/java/clearchat/ClearChatAction.java

+1 −1

package clearchat;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.exception.StreamPiException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class ClearChatAction extends NormalAction

{

private final String channelNameKey = "channel_name_cc";

private Twirk twirk;

@Override

public void initProperties() throws MinorException

{

setName("Clear Chat");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initAction() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

addClientProperties(channelName);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage("/clear");

} catch (Exception ex)

{

throw new MinorException(

String.format("Could not clear chat for '%s' channel, please try again.", channel)

);

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null)

{

try

{

twirk.disconnect();

} catch (Exception ex)

{

throw new MinorException("Twitch Connection error - Please try again.");

}

M twitch/emote-only/src/main/java/emote_only/EmoteOnlyAction.java

+1 −1

package emote_only;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.gikk.twirk.events.TwirkListener;

import com.gikk.twirk.types.roomstate.Roomstate;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class EmoteOnlyAction extends ToggleAction

{

private final String channelNameKey = "channel_name_eo";

private Twirk twirk;

public EmoteOnlyAction()

{

setName("Toggle Emote-Only Chat");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

addClientProperties(channelName);

}

@Override

public void onToggleOn() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/emoteonly");

} catch (Exception ex)

{

setCurrentStatus(false);

throw new MinorException("Failed to enable emote-only mode.", "Please try again.");

}

@Override

public void onToggleOff() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/emoteonlyoff");

} catch (Exception ex)

{

setCurrentStatus(true);

throw new MinorException("Failed to disable emote-only mode.", "Please try again.");

}

private void connectToChannel() throws Exception

{

if (twirk != null)

{

if (!twirk.isConnected())

{

twirk.connect();

}

return;

}

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.addIrcListener(new TwirkListener()

{

@Override

public void onRoomstate(Roomstate roomstate)

{

try

{

setCurrentStatus(roomstate.getEmoteOnlyMode() == 1);

} catch (MinorException e)

{

throw new RuntimeException(e);

}

});

twirk.connect();

} catch (Exception ex)

{

throw new MinorException("Failed to connect to Twitch",

String.format("Could not connect to '%s' channel.", channel));

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null)

{

try

{

twirk.disconnect();

} catch (Exception ex)

{

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/followers-only/src/main/java/followers_only/FollowersOnlyAction.java

+1 −1

package followers_only;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.gikk.twirk.events.TwirkListener;

import com.gikk.twirk.types.roomstate.Roomstate;

import com.stream_pi.action_api.actionproperty.property.ListValue;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

import java.util.ArrayList;

import java.util.Arrays;

public class FollowersOnlyAction extends ToggleAction

{

private final String channelNameKey = "channel_name_fo";

private final String durationKey = "duration_fo";

private final ArrayList<ListValue> durations;

private Twirk twirk;

public FollowersOnlyAction()

{

setName("Toggle Followers-Only Chat");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

durations = new ArrayList<>();

durations.addAll(Arrays.asList(

new ListValue("all"),

new ListValue("30m"),

new ListValue("2h"),

new ListValue("2d"),

new ListValue("1w"),

new ListValue("3mo")

));

}

@Override

public void initProperties() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

Property duration = new Property(durationKey, Type.LIST);

duration.setDisplayName("Follow Duration");

duration.setListValue(durations);

addClientProperties(channelName, duration);

}

@Override

public void onToggleOn() throws MinorException

{

try

{

connectToChannel();

final String followerDuration = durations.get(getClientProperties().getSingleProperty(durationKey)

.getSelectedIndex()).getName().toString();

if (followerDuration.equals("all"))

{

twirk.channelMessage("/followers");

} else {

twirk.channelMessage(String.format("/followers %s", followerDuration));

}

} catch (Exception ex)

{

setCurrentStatus(false);

throw new MinorException("Failed to enable followers only mode.", "Please try again.");

}

@Override

public void onToggleOff() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/followersoff");

} catch (Exception ex)

{

setCurrentStatus(true);

throw new MinorException("Failed to disable followers only mode.", "Please try again.");

}

private void connectToChannel() throws Exception

{

if (twirk != null)

{

if (!twirk.isConnected())

{

twirk.connect();

}

return;

}

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.addIrcListener(new TwirkListener()

{

@Override

public void onRoomstate(Roomstate roomstate)

{

try

{

setCurrentStatus(roomstate.getFollowersMode() == 1);

} catch (MinorException e)

{

throw new RuntimeException(e);

}

});

twirk.connect();

} catch (Exception ex)

{

throw new MinorException("Failed to connect to Twitch",

String.format("Could not connect to '%s' channel.", channel));

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null)

{

try

{

twirk.disconnect();

} catch (Exception ex)

{

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/host-channel/src/main/java/hostchannel/HostChannelAction.java

+1 −1

package hostchannel;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class HostChannelAction extends NormalAction

{

private final String channelKey = "channel_hc";

private final String channelToHostKey = "channel_to_host_hc";

private Twirk twirk;

public HostChannelAction()

{

setName("Host Channel");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channel = new Property(channelKey, Type.STRING);

channel.setDisplayName("Channel");

channel.setDefaultValueStr("channel");

channel.setCanBeBlank(false);

Property channelToHost = new Property(channelToHostKey, Type.STRING);

channelToHost.setDisplayName("Channel to host");

channelToHost.setDefaultValueStr("channel_to_host");

channelToHost.setCanBeBlank(false);

addClientProperties(channel, channelToHost);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelKey).getStringValue();

final String channelToHost = getClientProperties().getSingleProperty(channelToHostKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage(String.format("/host %s", channelToHost));

} catch (Exception ex)

{

throw new MinorException(

"Failed to host channel",

String.format("Could not host channel '%s', please try again.", channelToHost));

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error - Please try again.");

}

M twitch/raid-channel/src/main/java/raidchannel/RaidChannelAction.java

+1 −1

package raidchannel;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class RaidChannelAction extends NormalAction

{

private final String channelKey = "channel_rc";

private final String channelToRaidKey = "channel_to_raid_rc";

private Twirk twirk;

public RaidChannelAction()

{

setName("Raid Channel");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channel = new Property(channelKey, Type.STRING);

channel.setDisplayName("Channel");

channel.setDefaultValueStr("channel");

channel.setCanBeBlank(false);

Property channelToRaid = new Property(channelToRaidKey, Type.STRING);

channelToRaid.setDisplayName("Channel to raid");

channelToRaid.setDefaultValueStr("channel_to_raid");

channelToRaid.setCanBeBlank(false);

addClientProperties(channel, channelToRaid);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelKey).getStringValue();

final String channelToRaid = getClientProperties().getSingleProperty(channelToRaidKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage(String.format("/raid %s", channelToRaid));

} catch (Exception ex)

{

throw new MinorException(String.format("Could not raid channel '%s', please try again.", channelToRaid));

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error - Please try again.");

}

M twitch/send-channel-msg/src/main/java/sendchannelmsg/SendChannelMessageAction.java

+1 −1

package sendchannelmsg;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class SendChannelMessageAction extends NormalAction

{

private final String channelNameKey = "channel_name_scm";

private final String channelMsgKey = "channel_msg_scm";

private Twirk twirk;

public SendChannelMessageAction()

{

setName("Send Channel Message");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

Property channelMessage = new Property(channelMsgKey, Type.STRING);

channelMessage.setDisplayName("Message");

channelMessage.setDefaultValueStr("channel_msg");

channelMessage.setCanBeBlank(false);

addClientProperties(channelName, channelMessage);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

final String message = getClientProperties().getSingleProperty(channelMsgKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage(message);

} catch (Exception ex)

{

throw new MinorException(

"Failed to send channel message",

String.format("Could not send message '%s' to '%s' channel, please try again.",

channel, message)

);

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/set-color/src/main/java/setcolor/SetColorAction.java

+1 −1

package setcolor;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.ListProperty;

import com.stream_pi.action_api.actionproperty.property.ListValue;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class SetColorAction extends NormalAction

{

private final String channelNameKey = "channel_name_sc";

private final String usernameColorKey = "username_color_sc";

private Twirk twirk;

public SetColorAction()

{

setName("Set Color");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

colors = new ArrayList<>();

colors.addAll(

Arrays.asList(

new ListValue("Blue"),

new ListValue("Coral"),

new ListValue("DodgerBlue", "Dodger Blue"),

new ListValue("SpringGreen", "Spring Green"),

new ListValue("YellowGreen", "Yellow Green"),

new ListValue("Green"),

new ListValue("OrangeRed", "Orange Red"),

new ListValue("Red"),

new ListValue("GoldenRod", "Golden Rod"),

new ListValue("HotPink", "Hot Pink"),

new ListValue("CadetBlue", "Cadet Blue"),

new ListValue("SeaGreen", "Sea Green"),

new ListValue("Chocolate"),

new ListValue("BlueViolet", "Blue Violet"),

new ListValue("Firebrick")

)

);

}

private final ArrayList<ListValue> colors;

@Override

public void initAction() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

ListProperty usernameColor = new ListProperty(usernameColorKey);

usernameColor.setDisplayName("Color");

usernameColor.setListValue(colors);

addClientProperties(channelName, usernameColor);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

final String color = colors.get(getClientProperties().getSingleProperty(usernameColorKey).getSelectedIndex()).getName().toString();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage(String.format("/color %s", color));

} catch (Exception ex)

{

throw new MinorException(

"Failed to change username color",

String.format("Could not change username color to '%s' for '%s' channel, please try again.",

color, channel)

);

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/slow-mode/src/main/java/slow_mode/SlowModeAction.java

+1 −1

package slow_mode;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.gikk.twirk.events.TwirkListener;

import com.gikk.twirk.types.roomstate.Roomstate;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class SlowModeAction extends ToggleAction

{

private final String channelNameKey = "channel_name_sm";

private final String slowModeDurationKey = "slow_mode_duration";

private Twirk twirk;

public SlowModeAction()

{

setName("Toggle Slow Mode");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

Property durationInSecs = new Property(slowModeDurationKey, Type.INTEGER);

durationInSecs.setDefaultValueInt(600);

durationInSecs.setDisplayName("Duration (in seconds)");

addClientProperties(channelName, durationInSecs);

}

@Override

public void onToggleOn() throws MinorException

{

try

{

connectToChannel();

final int duration = getClientProperties().getSingleProperty(slowModeDurationKey).getIntValue();

twirk.channelMessage(String.format("/slow %d", duration));

} catch (Exception ex)

{

setCurrentStatus(false);

throw new MinorException("Failed to enable slow mode.", "Please try again.");

}

@Override

public void onToggleOff() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/slowoff");

} catch (Exception ex)

{

setCurrentStatus(true);

throw new MinorException("Failed to disable slow mode.", "Please try again.");

}

private void connectToChannel() throws Exception

{

if (twirk != null) {

if (!twirk.isConnected()) {

twirk.connect();

}

return;

}

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.addIrcListener(new TwirkListener()

{

@Override

public void onRoomstate(Roomstate roomstate)

{

try

{

setCurrentStatus(roomstate.getSlowModeTimer() > 0);

} catch (MinorException e)

{

throw new RuntimeException(e);

}

});

twirk.connect();

} catch (Exception ex)

{

throw new MinorException("Failed to connect to Twitch",

String.format("Could not connect to '%s' channel.", channel));

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null)

{

try

{

twirk.disconnect();

} catch (Exception ex)

{

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/start-commercial/src/main/java/startcommercial/StartCommercialAction.java

+1 −1

package startcommercial;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.ListValue;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class StartCommercialAction extends NormalAction

{

private final String channelNameKey = "channel_name_sca";

private final String durationKey = "duration_sca";

private Twirk twirk;

public StartCommercialAction()

{

setName("Start commercial");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

durations = new ArrayList<>();

durations.addAll(Arrays.asList(

new ListValue("30"),

new ListValue("60"),

new ListValue("90"),

new ListValue("120"),

new ListValue("150"),

new ListValue("180")

));

}

@Override

public void initProperties() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

Property duration = new Property(durationKey, Type.LIST);

duration.setDisplayName("Duration");

duration.setListValue(durations);

addClientProperties(channelName, duration);

}

private final ArrayList<ListValue> durations;

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

final String duration = durations.get(getClientProperties().getSingleProperty(durationKey).getSelectedIndex()).getName().toString();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage(String.format("/commercial %s", duration));

} catch (Exception ex)

{

throw new MinorException(

"Failed to start commercial", "Could not start commercial, please try again.");

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/subs-only/src/main/java/subs_only/SubsOnlyAction.java

+1 −1

package subs_only;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.gikk.twirk.events.TwirkListener;

import com.gikk.twirk.types.roomstate.Roomstate;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.ToggleAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class SubsOnlyAction extends ToggleAction

{

private final String channelNameKey = "channel_name_so";

private Twirk twirk;

public SubsOnlyAction()

{

setName("Toggle Subs-Only Chat");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channelName = new Property(channelNameKey, Type.STRING);

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

addClientProperties(channelName);

}

@Override

public void onToggleOn() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/subscribers");

} catch (Exception ex)

{

setCurrentStatus(false);

throw new MinorException("Failed to enable subscribers only mode.", "Please try again.");

}

@Override

public void onToggleOff() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/subscribersoff");

} catch (Exception ex)

{

setCurrentStatus(true);

throw new MinorException("Failed to disable subscribers only mode.", "Please try again.");

}

private void connectToChannel() throws Exception

{

if (twirk != null)

{

if (!twirk.isConnected())

{

twirk.connect();

}

return;

}

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.addIrcListener(new TwirkListener()

{

@Override

public void onRoomstate(Roomstate roomstate)

{

try

{

setCurrentStatus(roomstate.getSubMode() == 1);

} catch (MinorException e)

{

throw new RuntimeException(e);

}

});

twirk.connect();

} catch (Exception ex)

{

throw new MinorException("Failed to connect to Twitch",

String.format("Could not connect to '%s' channel.", channel));

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null)

{

try

{

twirk.disconnect();

} catch (Exception ex)

{

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/twitch-chat-connect/src/main/java/connect/TwitchChatConnectAction.java

+1 −1

package connect;

import com.stream_pi.action_api.actionproperty.property.ControlType;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.alert.StreamPiAlert;

import com.stream_pi.util.alert.StreamPiAlertType;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

import javafx.scene.control.Button;

public class TwitchChatConnectAction extends NormalAction

{

private static final String ACCESS_TOKEN_KEY = "twitch_chat_access_token";

private static final String NICKNAME_KEY = "twitch_chat_nickname";

private final Button clearCredentialsBtn;

public TwitchChatConnectAction()

{

setName("Twitch Chat Plugin");

setCategory("Twitch Chat");

setVisibilityInPluginsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

clearCredentialsBtn = new Button("Clear Twitch chat credentials");

onClearCredentials();

setServerSettingsButtonBar(clearCredentialsBtn);

}

@Override

public void onActionClicked() throws MinorException

{

}

@Override

public void initProperties() throws MinorException

{

Property twitchNicknameProp = new Property(NICKNAME_KEY, Type.STRING);

twitchNicknameProp.setDisplayName("Twitch Username");

Property twitchAccessTokenProp = new Property(ACCESS_TOKEN_KEY, Type.STRING);

twitchAccessTokenProp.setControlType(ControlType.TEXT_FIELD_MASKED);

twitchAccessTokenProp.setDisplayName("Access Token");

addServerProperties(twitchNicknameProp, twitchAccessTokenProp);

}

@Override

public void initAction() throws MinorException

{

clearCredentialsBtn.setDisable(isEmptyCredentials());

TwitchChatCredentials.setCredentials(

new TwitchChatCredentials.ChatCredentials()

.setOauthToken(getServerProperties().getSingleProperty(ACCESS_TOKEN_KEY).getStringValue())

.setNickname(getServerProperties().getSingleProperty(NICKNAME_KEY).getStringValue()));

}

private boolean isEmptyCredentials() throws MinorException {

final String twitchNickname = getServerProperties().getSingleProperty(NICKNAME_KEY).getStringValue();

final String twitchChatOauthToken = getServerProperties().getSingleProperty(ACCESS_TOKEN_KEY).getStringValue();

return (twitchNickname == null || twitchNickname.isEmpty()) &&

(twitchChatOauthToken == null || twitchChatOauthToken.isEmpty());

}

private void onClearCredentials()

{

clearCredentialsBtn.setOnAction(action ->

{

try

{

getServerProperties().getSingleProperty(ACCESS_TOKEN_KEY).setStringValue("");

getServerProperties().getSingleProperty(NICKNAME_KEY).setStringValue("");

saveServerProperties();

new StreamPiAlert(

"Twitch chat credentials cleared",

"To revoke token access, disconnect \"Twitch Chat OAuth Token Generator\" from your Twitch settings (https://www.twitch.tv/settings/connections).",

StreamPiAlertType.INFORMATION)

.show();

} catch (Exception e)

{

new StreamPiAlert(

"Failed to save chat credentials",

"An error has occurred while clearing chat credentials, please try again.",

StreamPiAlertType.WARNING)

.show();

}

});

}

M twitch/twitch-chat-connect/src/main/java/connect/chat/TwitchChatCredentials.java

+1 −0

package connect.chat;

import com.stream_pi.util.exception.MinorException;

public final class TwitchChatCredentials

{

public static final String HELP_LINK = "https://github.com/stream-pi/essential-actions/blob/master/twitch/README.md";

private static ChatCredentials credentials;

public static ChatCredentials getCredentials()

{

return credentials;

}

public static void setCredentials(ChatCredentials chatCredentials)

{

credentials = chatCredentials;

}

public static class ChatCredentials

{

String nickname;

String oauthToken;

public void ensureCredentialsInitialized() throws MinorException

{

final String twitchNickname = nickname;

boolean isNicknameInitialized = twitchNickname != null && !twitchNickname.isEmpty();

final String twitchChatOauthToken = oauthToken;

boolean isTokenInitialized = twitchChatOauthToken != null && !twitchChatOauthToken.isEmpty();

if (!isNicknameInitialized && !isTokenInitialized)

{

throw new MinorException(

"Twitch Chat config uninitialized\n" +

"Please check that the Twitch Chat plugin configuration is correct.");

}

public String getNickname()

{

return nickname;

}

public ChatCredentials setNickname(String nickname)

{

this.nickname = nickname;

return this;

}

public String getOauthToken()

{

return oauthToken;

}

public ChatCredentials setOauthToken(String oauthToken)

{

this.oauthToken = oauthToken;

return this;

}

M twitch/unhost/src/main/java/unhost/UnhostAction.java

+1 −1

package unhost;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class UnhostAction extends NormalAction

{

private final String channelNameKey = "channel_name_uh";

private Twirk twirk;

public UnhostAction()

{

setName("Unhost");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channel = new Property(channelNameKey, Type.STRING);

channel.setDisplayName("Host Channel");

channel.setDefaultValueStr("channel_name");

channel.setCanBeBlank(false);

addClientProperties(channel);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage("/unhost");

} catch (Exception ex)

{

throw new MinorException(

"Failed to cancel channel hosting",

"Could not cancel channel hosting, please try again.");

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/unraid/src/main/java/unraid/UnraidAction.java

+1 −1

package unraid;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class UnraidAction extends NormalAction

{

private final String channelNameKey = "channel_name_ur";

private Twirk twirk;

public UnraidAction()

{

setName("Unraid");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property channel = new Property(channelNameKey, Type.STRING);

channel.setDisplayName("Channel");

channel.setDefaultValueStr("channel_name");

channel.setCanBeBlank(false);

addClientProperties(channel);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String channel = getClientProperties().getSingleProperty(channelNameKey).getStringValue();

try

{

twirk = new TwirkBuilder(channel, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.channelMessage("/unraid");

} catch (Exception ex)

{

throw new MinorException(

"Failed to cancel channel raid",

"Could not cancel channel raid, please try again.");

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error", "Please try again.");

}

M twitch/whisper/src/main/java/whisper/WhisperAction.java

+1 −1

package whisper;

import com.gikk.twirk.Twirk;

import com.gikk.twirk.TwirkBuilder;

import com.stream_pi.action_api.actionproperty.property.Property;

import com.stream_pi.action_api.actionproperty.property.Type;

import com.stream_pi.action_api.externalplugin.NormalAction;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class WhisperAction extends NormalAction

{

private final String usernameKey = "username_wa";

private final String messageKey = "message_wa";

private Twirk twirk;

public WhisperAction()

{

setName("Whisper");

setCategory("Twitch Chat");

setVisibilityInServerSettingsPane(false);

setAuthor("j4ckofalltrades");

setVersion(new Version(1, 0, 0));

setHelpLink("https://github.com/stream-pi/essentialactions#twitch-chat-integration");

setHelpLink(TwitchChatCredentials.HELP_LINK);

}

@Override

public void initProperties() throws MinorException

{

Property usernameProp = new Property(usernameKey, Type.STRING);

usernameProp.setDisplayName("Twitch Username");

usernameProp.setDefaultValueStr("username");

usernameProp.setCanBeBlank(false);

Property messageProp = new Property(messageKey, Type.STRING);

messageProp.setDisplayName("Message");

messageProp.setDefaultValueStr("message");

messageProp.setCanBeBlank(false);

addClientProperties(usernameProp, messageProp);

}

@Override

public void onActionClicked() throws MinorException

{

final TwitchChatCredentials.ChatCredentials credentials = TwitchChatCredentials.getCredentials();

credentials.ensureCredentialsInitialized();

final String username = getClientProperties().getSingleProperty(usernameKey).getStringValue();

final String message = getClientProperties().getSingleProperty(messageKey).getStringValue();

try

{

twirk = new TwirkBuilder(username, credentials.getNickname(), credentials.getOauthToken()).build();

twirk.connect();

twirk.whisper(username, message);

} catch (Exception ex)

{

throw new MinorException(

"Failed to send message to user",

String.format("Could not send message '%s' to user '%s', please try again.",

username, message)

);

}

@Override

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

throw new MinorException("Twitch connection error", "Please try again.");

}

Public

essential-actions

Clone or download

[Twitch] - Add Better help link master

Modified Files