//https://docs.microsoft.com/en-us/archive/msdn-magazine/2013/march/async-await-best-practices-in-asynchronous-programming#:~:text=Avoid%20Async%20Void
private async void onRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
if (e.RewardTitle == "puppy-rain")
{
await _connection.InvokeAsync("SendMessage", e.DisplayName, "It's a torrential downpour of destructopups!!!", MessageTypeEnum.SuperRain);
}
}
public async Task <RewardRedemption> UpdateRedemptionReward(OnRewardRedeemedArgs events, CustomRewardRedemptionStatus status)
{
try
{
var response = await API.Helix.ChannelPoints.UpdateCustomRewardRedemptionStatus(events.ChannelId, events.RewardId.ToString(),
new List <string>() { events.RedemptionId.ToString() },
new UpdateCustomRewardRedemptionStatusRequest()
{
Status = status
},
this.accessToken);
_logger.Information($"{response.Data[0]}");
return(response.Data[0]);
}
catch (InvalidCredentialException e)
{
_logger.Information($"{e.Message}");
await RefreshAccessToken();
return(await UpdateRedemptionReward(events, status));
}
catch (Exception e)
{
_logger.Error($"{e.Message}");
throw e;
}
}
private async Task FulfillCustomReward(OnRewardRedeemedArgs e)
{
if (e.RewardTitle == Constants.KillPlayerString)
{
if (isValidCustomReward(e.RewardPrompt, e.Message))
{
_logger.Information($"This is a valid kill. Sending over to Among Us Mod");
// If the pipe returns success, call UpdateCustomRewardRedemptionStatus with status fulfilled
SendToPipe("killplayer:" + e.RewardPrompt);
await API.UpdateRedemptionReward(e, CustomRewardRedemptionStatus.FULFILLED);
}
else
{
_logger.Information($"This is not a valid kill. We are returning the points.");
await API.UpdateRedemptionReward(e, CustomRewardRedemptionStatus.CANCELED);
}
}
else if (e.RewardTitle == Constants.KillRandomPlayerString)
{
_logger.Information($"Going to kill random player");
// If the pipe returns success, call UpdateCustomRewardRedemptionStatus with status fulfilled
SendToPipe("killrandomplayer");
await API.UpdateRedemptionReward(e, CustomRewardRedemptionStatus.FULFILLED);
}
else if (e.RewardTitle == Constants.SwapPlayersString)
{
_logger.Information($"Going to swap players");
// If the pipe returns success, call UpdateCustomRewardRedemptionStatus with status fulfilled
SendToPipe("swapplayers");
await API.UpdateRedemptionReward(e, CustomRewardRedemptionStatus.FULFILLED);
}
}
private void Upgrade(OnRewardRedeemedArgs e, bool isExp, int sum)
{
using (var context = new AppDbContext())
{
var user = context.Users.GetByLogin(e.Login);
if (user == null)
{
LogInfo(e);
return;
}
if (isExp)
{
user.Experience += sum;
}
else
{
user.Money += sum;
}
var rewardHistory = new RewardHistory()
{
User = user,
Name = e.RewardTitle,
Guid = e.RewardId,
Cost = e.RewardCost,
Date = DateTime.Now,
FactUp = sum,
IsExp = isExp
};
context.RewardHistories.Add(rewardHistory);
context.SaveChanges();
}
}
public static void UkrainianStreamRewardCallback(object s, OnRewardRedeemedArgs e, CallbackArgs args)
{
//TwitchHelpers.FulFillRedemption(args.e.ChannelId, args.e.RewardId.ToString(), args.e.RedemptionId.ToString());
var rewardTimespan = TimeSpan.FromMinutes(15);
args.ChannelInfo.Lang = Lang.ua;
Task.Delay(rewardTimespan).ContinueWith(_ => args.ChannelInfo.Lang = Lang.ru);
}
private void OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
if (!e.Status.Equals("UNFULFILLED"))
{
return;
}
_notifierMediatorService.NotifyPattern(e.RewardTitle.ToLowerInvariant(), e);
}
private void _pubSub_OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
if (SettingsSingleton.Instance.genSettings.RedemptionsEnabled)
{
PushNewChatMessage(
$"redeemed '{e.RewardTitle}' ({e.RewardCost} points)", // ~ {e.ChannelId}",
e.DisplayName, "#708090");
}
}
private void ClientOnOnRewardRedeemed(object?sender, OnRewardRedeemedArgs e)
{
IRewardRedemption rewardRedemption = e.ToRewardRedemption();
foreach (IRewardRedeemHandler rewardRedeemHandler in this.rewardRedeemHandlers)
{
rewardRedeemHandler.Handle(rewardRedemption);
}
}
private void onRewardRedeemed(object?sender, OnRewardRedeemedArgs args)
{
/*
* _Logger.LogInformation($"{args.DisplayName} redeemed {args.RewardId}/{args.RewardTitle}\n\tPrompt:{args.RewardPrompt}\n\tCost:{args.RewardCost}\n\tMessage: {args.Message}\n\tLogin: {args.Login} {args.Status} {args.TimeStamp}");
*
* if (args.RewardTitle == "monkaW") {
* _Challenges.Start(1);
* }
*/
}
private void PubSub_OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
Console.WriteLine(e.RewardTitle.Trim() + " was redeemed!");
bool useKeywords = !String.IsNullOrEmpty(e.Message);
Setting settings = repository.LoadSettings();
if (String.IsNullOrEmpty(settings.Application))
{
Console.WriteLine("is there any point?");
return;
}
List <Trigger> triggers = repository.GetTriggers().Where(trigger => !String.IsNullOrEmpty(trigger.RewardName)).ToList <Trigger>();
foreach (Trigger trigger in triggers)
{
if (trigger.RewardName != e.RewardTitle.Trim())
{
continue;
}
if (useKeywords)
{
if (!PassesKeywordCheck(trigger.Keywords, e.Message))
{
continue;
}
}
Console.WriteLine("matched!!");
SendKeystroke.Send(settings.Application, trigger.CharAnimTriggerKeyValue);
DateTime triggeredAt = DateTime.Now;
repository.UpdateTriggerUsage(trigger.Name, triggeredAt);
BotTriggeredArgs args = new BotTriggeredArgs {
TriggeredAt = triggeredAt
};
BotTriggered?.Invoke(this, args);
if (settings.LoggingEnabled)
{
Logger.Write($"{trigger.Name} (REWARD: {e.RewardTitle.Trim()})", e.DisplayName, e.RewardCost, e.Message);
}
if (useKeywords)
{
break;
}
}
}
//Pure Debug to see what containes a OnRewardRedeemedArgs
void RewardRedeemedDebug(OnRewardRedeemedArgs e)
{
Console.WriteLine("Points redeemed");
Console.WriteLine(e.Login);
Console.WriteLine(e.Message);
Console.WriteLine(e.RewardCost);
Console.WriteLine(e.RewardId);
Console.WriteLine(e.RewardPrompt);
Console.WriteLine(e.RewardTitle);
Console.WriteLine(e.Status);
Console.WriteLine(e.TimeStamp);
}
internal static RewardRedeemedEvent Create(OnRewardRedeemedArgs e)
=> new RewardRedeemedEvent
{
ChannelId = e.ChannelId,
DisplayName = e.DisplayName,
Login = e.Login,
Message = e.Message,
RewardCost = e.RewardCost,
RewardId = e.RewardId,
RewardPrompt = e.RewardPrompt,
RewardTitle = e.RewardTitle,
Status = e.Status,
TimeStamp = e.TimeStamp
};
public bool TryGetReward(OnRewardRedeemedArgs args, out SupportedReward reward)
{
reward = null;
foreach (var item in Rewards)
{
if (item.Title == args.RewardTitle)
{
reward = item;
return(true);
}
}
return(false);
}
private async void OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
// Check if the reward is a buy spice reward in the format ... (xN) where N is amount of spice bought
if (e.Status == "ACTION_TAKEN")
{
Regex rxCheck = new Regex(@"\d+",
RegexOptions.Compiled | RegexOptions.IgnoreCase);
MatchCollection matches = rxCheck.Matches(e.RewardTitle);
foreach (Match match in matches)
{
int amount = Int32.Parse(match.Value);
TwitchLib.Api.V5.Models.Users.Users user = await UsernameToUser(e.DisplayName);
UpdateSpiceStorage(ref userStorage, user.Matches[0].Id, user.Matches[0].DisplayName, amount);
}
}
}
private async void PubSub_OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
//Statuses can be:
// "UNFULFILLED": when a user redeemed the reward
// "FULFILLED": when a broadcaster or moderator marked the reward as complete
if (e.Status == "UNFULFILLED")
{
_logger.Information($"{e.DisplayName} redeemed: {e.RewardTitle} " +
$"with prompt ${e.RewardPrompt.Split()}. With message: {e.Message}");
await FulfillCustomReward(e);
}
if (e.Status == "FULFILLED")
{
_logger.Information($"Reward from {e.DisplayName} ({e.RewardTitle}) has been marked as complete");
}
}
/// <summary>
/// Checks the bindings array and plays the appropriate sound file when a Channel Points reward is redeemed.
/// </summary>
private void OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
#if DEBUG
Debug.WriteLine("Reward Redeemed:");
Debug.WriteLine("\tTitle:" + e.RewardTitle + "|");
Debug.WriteLine("\tPrompt:" + e.RewardPrompt + "|");
Debug.WriteLine("\tUser:"******"|");
Debug.WriteLine("\tStatus:" + e.Status + "|");
Debug.WriteLine("----------------");
#endif
if (bindings.ContainsKey(e.RewardTitle) && e.Status != "ACTION_TAKEN")
{
bindings.TryGetValue(e.RewardTitle, out string output);
#if DEBUG
Debug.WriteLine(output);
#endif
PlaySound(output);
}
}
private async void CheckReward(OnRewardRedeemedArgs e)
{
await Task.Run(() =>
{
try
{
if (e.RewardTitle.Contains("10к опыта в игре") || e.RewardId.ToString().ToLower() == "b2a275fe-b37e-4d69-bde4-9d59f0c39b7e")
{
Upgrade(e, true, 10000);
}
else if (e.RewardTitle.Contains("30к опыта в игре") || e.RewardId.ToString().ToLower() == "36827cd8-001d-4735-9b1e-7dbaf9604b2f")
{
Upgrade(e, true, 30000);
}
else if (e.RewardTitle.Contains("70к опыта в игре") || e.RewardId.ToString().ToLower() == "8fd25e79-1f1d-4d01-9096-df0e372e9cc1")
{
Upgrade(e, true, 70000);
}
else if (e.RewardTitle.Contains("10к денег в игре") || e.RewardId.ToString().ToLower() == "30db925c-97dc-4a8b-b9ab-570888095aef")
{
Upgrade(e, false, 10000);
}
else if (e.RewardTitle.Contains("30к денег в игре") || e.RewardId.ToString().ToLower() == "918d3bb0-7dc1-4e20-92d2-f5ee9a2c1c3e")
{
Upgrade(e, false, 30000);
}
else if (e.RewardTitle.Contains("70к денег в игре") || e.RewardId.ToString().ToLower() == "fe8df898-1f48-474c-bce4-334c707f9e72")
{
Upgrade(e, false, 70000);
}
else if (e.RewardCost >= 10000)
{
LogInfo(e);
}
}
catch (Exception ex)
{
Logger.LogRewardError(ex);
LogInfo(e);
}
});
}
public RewardRequest Create(SupportedReward reward, OnRewardRedeemedArgs args)
{
if (reward.RewardType == RewardType.ReplayId && !string.IsNullOrWhiteSpace(args.Message) && int.TryParse(args.Message.Trim(), out int replayId))
{
return(new RewardRequest(args.Login, args.RedemptionId, reward.Title, replayId, rank: null, reward.Map, reward.Mode));
}
else
{
if (reward.RewardType.HasFlag(RewardType.Rank) && Enum.TryParse(args.Message, ignoreCase: true, out GameRank rank))
{
return(new RewardRequest(args.Login, args.RedemptionId, reward.Title, replayId: null, rank: rank, reward.Map, reward.Mode));
}
else
{
return(new RewardRequest(args.Login, args.RedemptionId, reward.Title, replayId: null, rank: null, reward.Map, reward.Mode));
}
}
throw new NotSupportedException();
}
public void Execute(SupportedReward reward, OnRewardRedeemedArgs args)
{
Task.Factory.StartNew(async() =>
{
try
{
logger.LogInformation($"{args.Login} has redeemed {args.RewardTitle}");
RewardResponse response = await queue.EnqueueItemAsync(rewardRequestFactory.Create(reward, args));
if (settings.Twitch.EnableChatBot)
{
twitchClient.SendMessage(settings.Twitch.Channel, $"{args.DisplayName}, {response.Message}", dryRun: settings.Twitch.DryRunMode);
}
}
catch (Exception e)
{
logger.LogError(e, $"Could not queue reward: {reward.Title}");
}
}, TaskCreationOptions.LongRunning);
}
public void Handle(OnRewardRedeemedArgs args)
{
if (rewards.TryGetReward(args, out SupportedReward reward))
{
foreach (var handler in handlers.Where(handler => handler.Supports.Contains(reward.RewardType)))
{
try
{
handler.Execute(reward, args);
}
catch (Exception e) when(handler != null)
{
logger.LogError(e, $"Could not execute handler: {handler.GetType().Name}");
}
}
}
else
{
logger.LogWarning($"Could not handle reward '{args.RewardTitle}' because it was not found");
}
}
public void OnRewardRedeemedEvent(OnRewardRedeemedArgs args)
{
this.OnRewardRedeemed?.Invoke(this, args);
if (!this.events.ContainsKey(EventType.Redeem))
{
return;
}
var tokenReplacements = new List <KeyValuePair <string, string> >();
tokenReplacements.Add(new KeyValuePair <string, string>("{{user}}", args.DisplayName));
tokenReplacements.Add(new KeyValuePair <string, string>("{{reward}}", args.RewardTitle));
tokenReplacements.Add(new KeyValuePair <string, string>("{{message}}", args.Message));
// Filter only redeems with matching title
foreach (var redeemEvent in this.events[EventType.Redeem].Where(redeem => redeem.Option.ToLowerInvariant() == args.RewardTitle.ToLowerInvariant()))
{
SendEventMessageInChat(redeemEvent, tokenReplacements);
}
}
public void Execute(SupportedReward reward, OnRewardRedeemedArgs args)
{
if (!string.IsNullOrWhiteSpace(args.Message) && int.TryParse(args.Message.Trim(), out int replayId))
{
Task.Factory.StartNew(async() =>
{
RewardResponse response = await queue.EnqueueItemAsync(requestFactory.Create(reward, args));
if (settings.Twitch.EnableChatBot)
{
string message = $"{args.DisplayName}, {response.Message}";
twitchClient.SendMessage(settings.Twitch.Channel, message, dryRun: settings.Twitch.DryRunMode);
}
}, TaskCreationOptions.LongRunning);
}
else
{
twitchClient.SendMessage(settings.Twitch.Channel, $"{args.DisplayName}, your request is invalid.", dryRun: settings.Twitch.DryRunMode);
logger.LogDebug($"{args.TimeStamp}: {args.RewardId} - {args.RewardCost}");
}
}
private void PubSub_OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
//Statuses can be:
// "UNFULFILLED": when a user redeemed the reward
// "FULFILLED": when a broadcaster or moderator marked the reward as complete
if (e.Status == "UNFULFILLED")
{
_logger.Information($"{e.DisplayName} redeemed: {e.RewardTitle}");
API.Helix.ChannelPoints.UpdateCustomRewardRedemptionStatus(e.ChannelId, e.RewardId.ToString(),
new List <string>()
{
e.RedemptionId.ToString()
}, new UpdateCustomRewardRedemptionStatusRequest()
{
Status = CustomRewardRedemptionStatus.CANCELED
});
}
if (e.Status == "FULFILLED")
{
_logger.Information($"Reward from {e.DisplayName} ({e.RewardTitle}) has been marked as complete");
}
}
public RewardRedeemedArgsWrapper(OnRewardRedeemedArgs onRewardRedeemedArgs)
{
this.onRewardRedeemedArgs = onRewardRedeemedArgs;
}
public GrowCommand(OnRewardRedeemedArgs rewardRedeemedArgs)
{
RewardRedeemedArgs = rewardRedeemedArgs;
}
private void onRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
throw new NotImplementedException();
}
public static IRewardRedemption ToRewardRedemption(this OnRewardRedeemedArgs args)
{
return(new RewardRedeemedArgsWrapper(args));
}
private void LogInfo(OnRewardRedeemedArgs e)
{
var str = CantParseMessage.Format(e.RewardTitle, e.RewardId, e.RewardCost, e.Login, e.DisplayName);
Logger.LogRewardInfo(str);
}
private void OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
CheckReward(e);
}
private void PubSub_OnRewardRedeemed(object sender, OnRewardRedeemedArgs e)
{
onRewardHandler.Handle(e);
}