essential-actions

Update Twitch actions to use latest action-api version

Download Browse

+50 −85

Author

Jordan Duabe 2021-06-02 21:19

Committer

Jordan Duabe 2021-06-02 21:19

Hash 4530b3e49fab9e685cf3c6d0caedc40c2cf7272c

Parent 8625e90bf278acdb21eb7b4664c770c047244f94

Reference git #essential-actions/4530b3e49fab9e685cf3c6d0caedc40c2cf7272c

Modified Files

List

Side by side diff

Inline diff

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

+0 −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.exception.StreamPiException;

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");

}

@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/host-channel/src/main/java/hostchannel/HostChannelAction.java

+0 −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.exception.StreamPiException;

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");

}

@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

+0 −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.exception.StreamPiException;

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");

}

@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

+6 −12

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.StreamPiException;

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");

}

@Override

public void initProperties() throws Exception

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 initAction() throws Exception

public void onActionClicked() throws MinorException

{

}

@Override

public void onActionClicked() throws Exception

{

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 StreamPiException(

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 Exception

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

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

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

}

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

+6 −6

package setcolor;

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.StreamPiException;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

public class SetColorAction extends NormalAction

{

private final String channelNameKey = "channel_name_sc";

private final String usernameColorKey = "username_color_sc";

private Twirk twirk;

@Override

public void initProperties() throws Exception

public void initProperties()

{

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");

}

@Override

public void initAction() throws Exception

{

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

channelName.setDisplayName("Channel Name");

channelName.setDefaultValueStr("channel_name");

channelName.setCanBeBlank(false);

Property usernameColor = new Property(usernameColorKey, Type.STRING);

usernameColor.setDisplayName("Color");

usernameColor.setDefaultValueStr("color");

usernameColor.setCanBeBlank(false);

addClientProperties(channelName, usernameColor);

}

@Override

public void onActionClicked() throws Exception

public void onActionClicked() throws MinorException

{

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

credentials.ensureCredentialsInitialized();

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

final String color = getClientProperties().getSingleProperty(usernameColorKey).getStringValue();

try

{

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

twirk.connect();

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

} catch (Exception ex)

{

throw new StreamPiException(

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 Exception

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

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

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

}

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

+7 −8

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.exception.StreamPiException;

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");

}

@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 Exception

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 StreamPiException("Failed to enable slow mode.", "Please try again.");

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

}

@Override

public void onToggleOff() throws Exception

public void onToggleOff() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/slowoff");

} catch (Exception ex)

{

setCurrentStatus(true);

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

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 StreamPiException("Failed to connect to Twitch",

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

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

}

@Override

public void onShutDown() throws Exception

public void onShutDown() throws MinorException

{

if (twirk != null)

{

try

{

twirk.disconnect();

} catch (Exception ex)

{

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

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

}

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

+6 −12

package startcommercial;

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.StreamPiException;

import com.stream_pi.util.exception.MinorException;

import com.stream_pi.util.version.Version;

import connect.chat.TwitchChatCredentials;

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");

}

@Override

public void initProperties() throws Exception

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(List.of(

String.valueOf(30),

String.valueOf(60),

String.valueOf(90),

String.valueOf(120),

String.valueOf(150),

String.valueOf(180)));

addClientProperties(channelName, duration);

}

@Override

public void initAction() throws Exception

public void onActionClicked() throws MinorException

{

}

@Override

public void onActionClicked() throws Exception

{

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

credentials.ensureCredentialsInitialized();

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

final String duration = getClientProperties().getSingleProperty(durationKey).getStringValue();

try

{

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

twirk.connect();

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

} catch (Exception ex)

{

throw new StreamPiException(

throw new MinorException(

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

}

@Override

public void onShutDown() throws Exception

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

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

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

}

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

+7 −8

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.exception.StreamPiException;

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");

}

@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 Exception

public void onToggleOn() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/subscribers");

} catch (Exception ex)

{

setCurrentStatus(false);

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

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

}

@Override

public void onToggleOff() throws Exception

public void onToggleOff() throws MinorException

{

try

{

connectToChannel();

twirk.channelMessage("/subscribersoff");

} catch (Exception ex)

{

setCurrentStatus(true);

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

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 StreamPiException("Failed to connect to Twitch",

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

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

}

@Override

public void onShutDown() throws Exception

public void onShutDown() throws MinorException

{

if (twirk != null)

{

try

{

twirk.disconnect();

} catch (Exception ex)

{

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

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

}

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

+6 −12

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.StreamPiException;

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");

}

@Override

public void initProperties() throws Exception

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 initAction() throws Exception

public void onActionClicked() throws MinorException

{

}

@Override

public void onActionClicked() throws Exception

{

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 StreamPiException(

throw new MinorException(

"Failed to cancel channel hosting",

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

}

@Override

public void onShutDown() throws Exception

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

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

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

}

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

+6 −12

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.StreamPiException;

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");

}

@Override

public void initProperties() throws Exception

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 initAction() throws Exception

public void onActionClicked() throws MinorException

{

}

@Override

public void onActionClicked() throws Exception

{

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 StreamPiException(

throw new MinorException(

"Failed to cancel channel raid",

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

}

@Override

public void onShutDown() throws Exception

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

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

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

}

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

+6 −12

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.StreamPiException;

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");

}

@Override

public void initProperties() throws Exception

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 initAction() throws Exception

public void onActionClicked() throws MinorException

{

}

@Override

public void onActionClicked() throws Exception

{

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 StreamPiException(

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 Exception

public void onShutDown() throws MinorException

{

if (twirk != null) {

try

{

twirk.disconnect();

} catch (Exception ex) {

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

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

}

Public

essential-actions

Clone or download

Update Twitch actions to use latest action-api version

Modified Files