/// <summary>
/// Processes a received text packet.
/// </summary>
/// <param name="packet">The text packet received</param>
/// <returns>An awaitable Task</returns>
protected override Task ProcessReceivedPacket(string packet)
{
Logger.Log(LogLevel.Debug, "Trovo Chat Packet: " + packet);
ChatPacketModel response = JSONSerializerHelper.DeserializeFromString <ChatPacketModel>(packet);
if (response != null && !string.IsNullOrEmpty(response.type))
{
switch (response.type)
{
case "RESPONSE":
if (this.replyIDListeners.ContainsKey(response.nonce))
{
this.replyIDListeners[response.nonce] = response;
}
break;
case "CHAT":
this.SendSpecificPacket(response, this.OnChatMessageReceived);
break;
}
}
return(Task.FromResult(0));
}
/// <summary>
/// Performs a GraphQL query with the specified query text and returns the specified type.
/// </summary>
/// <typeparam name="T">The type of the result</typeparam>
/// <param name="query">The query to perform</param>
/// <param name="key">The key to get for the data</param>
/// <returns>The result data</returns>
protected async Task <T> QueryAsync <T>(string query, string key)
{
try
{
GraphQLHttpClient client = await this.GetGraphQLClient();
GraphQLResponse <JObject> response = await client.SendQueryAsync <JObject>(new GraphQLRequest(query));
Logger.Log(LogLevel.Debug, JSONSerializerHelper.SerializeToString(response));
if (response.Errors != null && response.Errors.Length > 0)
{
foreach (GraphQLError error in response.Errors)
{
Logger.Log(LogLevel.Error, $"GraphQL Query Error: {query} - {error.Message}");
}
}
if (response.Data != null && response.Data.ContainsKey(key))
{
return(response.Data[key].ToObject <T>());
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
return(default(T));
}
/// <summary>
/// Creates a new instance of the ClientPacketModelBase class.
/// </summary>
/// <param name="serializedChatPacketArray">The serialized packet array</param>
protected ClientPacketModelBase(string serializedChatPacketArray)
: this()
{
JArray array = JSONSerializerHelper.DeserializeFromString <JArray>(serializedChatPacketArray);
if (array.Count > 0)
{
this.JoinRef = array[0]?.ToString();
}
if (array.Count > 1)
{
this.NormalRef = array[1]?.ToString();
}
if (array.Count > 2)
{
this.Topic = array[2]?.ToString();
}
if (array.Count > 3)
{
this.Event = array[3]?.ToString();
}
if (array.Count > 4 && array[4] != null)
{
this.Payload = (JObject)array[4];
}
}
public async Task SendTrigger(string eventName, Dictionary <string, string> values)
{
try
{
using (HttpClient client = new HttpClient())
{
JObject jobj = new JObject();
foreach (var kvp in values)
{
jobj[kvp.Key] = kvp.Value;
}
HttpContent content = new StringContent(JSONSerializerHelper.SerializeToString(jobj), Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.PostAsync(string.Format(WebHookURLFormat, eventName, this.token.accessToken), content);
if (!response.IsSuccessStatusCode)
{
Logger.Log(await response.Content.ReadAsStringAsync());
}
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
public async Task <UserDataModel> GetUserDataByPlatformUsername(StreamingPlatformTypeEnum platform, string platformUsername)
{
if (string.IsNullOrEmpty(platformUsername) || platform == StreamingPlatformTypeEnum.None || platform == StreamingPlatformTypeEnum.All)
{
return(null);
}
if (this.platformUsernameLookups[platform].TryGetValue(platformUsername, out Guid id) && this.UserData.TryGetValue(id, out UserDataModel userData))
{
return(userData);
}
string columnName = null;
switch (platform)
{
case StreamingPlatformTypeEnum.Twitch: columnName = "TwitchUsername"; break;
}
userData = null;
if (!string.IsNullOrEmpty(columnName))
{
await ChannelSession.Services.Database.Read(this.DatabaseFilePath, "SELECT * FROM Users WHERE " + columnName + " LIKE $PlatformUsername",
new Dictionary <string, object>() { { "$PlatformUsername", platformUsername } },
(Dictionary <string, object> data) =>
{
userData = JSONSerializerHelper.DeserializeFromString <UserDataModel>(data["Data"].ToString());
});
}
this.SetUserData(userData);
return(userData);
}
/// <summary>
/// Generates the serialized packet array for sending over the web socket connection.
/// </summary>
/// <returns>The serialized packet array</returns>
public string ToSerializedPacketArray()
{
return(JSONSerializerHelper.SerializeToString(new JArray()
{
this.JoinRef, this.NormalRef, this.Topic, this.Event, this.Payload
}));
}
private async Task <bool> ConnectSocket()
{
await this.socket.Connect("https://nodeapi.treatstream.com/", "token=" + this.socketToken);
this.socket.Listen("connect", (data) =>
{
this.WebSocketConnected = true;
});
this.socket.Listen("realTimeTreat", (data) =>
{
if (data != null)
{
TreatStreamEvent tsEvent = JSONSerializerHelper.DeserializeFromString <TreatStreamEvent>(data.ToString());
if (tsEvent != null)
{
this.DonationOccurred(tsEvent);
Task.Run(async() =>
{
await EventService.ProcessDonationEvent(EventTypeEnum.TreatStreamDonation, tsEvent.ToGenericDonation());
});
}
}
});
this.socket.Listen("error", async(errorData) =>
{
if (errorData != null)
{
Logger.Log(errorData.ToString());
}
this.WebSocketDisconnectedOccurred();
await this.ConnectSocket();
});
this.socket.Listen("disconnect", async(errorData) =>
{
if (errorData != null)
{
Logger.Log(errorData.ToString());
}
this.WebSocketDisconnectedOccurred();
await this.ConnectSocket();
});
for (int i = 0; i < 10 && !this.WebSocketConnected; i++)
{
await Task.Delay(1000);
}
if (this.WebSocketConnected)
{
this.WebSocketConnectedOccurred();
return(true);
}
return(false);
}
public T GetContent <T>()
{
if (!string.IsNullOrEmpty(this.content))
{
return(JSONSerializerHelper.DeserializeFromString <T>(this.content));
}
return(default(T));
}
public static async Task <T> DeserializeAbstractFromFile <T>(string filePath, bool ignoreErrors = false)
{
if (File.Exists(filePath))
{
return(JSONSerializerHelper.DeserializeAbstractFromString <T>(await FileSerializerHelper.fileService.ReadFile(filePath), ignoreErrors));
}
return(default(T));
}
public async Task SaveDatabaseData()
{
if (this.IsStreamer)
{
IEnumerable <Guid> removedUsers = this.UserData.GetRemovedValues();
await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "DELETE FROM Users WHERE ID = @ID", removedUsers.Select(u => new Dictionary <string, object>()
{
{ "@ID", u.ToString() }
}));
IEnumerable <UserDataModel> changedUsers = this.UserData.GetChangedValues();
await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "REPLACE INTO Users(ID, Data) VALUES(@ID, @Data)",
changedUsers.Select(u => new Dictionary <string, object>()
{
{ "@ID", u.ID.ToString() }, { "@Data", JSONSerializerHelper.SerializeToString(u) }
}));
List <Guid> removedCommands = new List <Guid>();
removedCommands.AddRange(this.ChatCommands.GetRemovedValues().Select(c => c.ID));
removedCommands.AddRange(this.EventCommands.GetRemovedValues().Select(c => c.ID));
removedCommands.AddRange(this.TimerCommands.GetRemovedValues().Select(c => c.ID));
removedCommands.AddRange(this.ActionGroupCommands.GetRemovedValues().Select(c => c.ID));
removedCommands.AddRange(this.GameCommands.GetRemovedValues().Select(c => c.ID));
removedCommands.AddRange(this.TwitchChannelPointsCommands.GetRemovedValues().Select(c => c.ID));
removedCommands.AddRange(this.CustomCommands.GetRemovedValues());
await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "DELETE FROM Commands WHERE ID = @ID",
removedCommands.Select(id => new Dictionary <string, object>()
{
{ "@ID", id.ToString() }
}));
List <CommandBase> addedChangedCommands = new List <CommandBase>();
addedChangedCommands.AddRange(this.ChatCommands.GetAddedChangedValues());
addedChangedCommands.AddRange(this.EventCommands.GetAddedChangedValues());
addedChangedCommands.AddRange(this.TimerCommands.GetAddedChangedValues());
addedChangedCommands.AddRange(this.ActionGroupCommands.GetAddedChangedValues());
addedChangedCommands.AddRange(this.GameCommands.GetAddedChangedValues());
addedChangedCommands.AddRange(this.TwitchChannelPointsCommands.GetAddedChangedValues());
addedChangedCommands.AddRange(this.CustomCommands.GetAddedChangedValues());
await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "REPLACE INTO Commands(ID, TypeID, Data) VALUES(@ID, @TypeID, @Data)",
addedChangedCommands.Select(c => new Dictionary <string, object>()
{
{ "@ID", c.ID.ToString() }, { "@TypeID", (int)c.Type }, { "@Data", JSONSerializerHelper.SerializeToString(c) }
}));
await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "DELETE FROM Quotes WHERE ID = @ID",
this.Quotes.GetRemovedValues().Select(q => new Dictionary <string, object>()
{
{ "@ID", q.ID.ToString() }
}));
await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "REPLACE INTO Quotes(ID, Data) VALUES(@ID, @Data)",
this.Quotes.GetAddedChangedValues().Select(q => new Dictionary <string, object>()
{
{ "@ID", q.ID.ToString() }, { "@Data", JSONSerializerHelper.SerializeToString(q.Model) }
}));
}
}
/// <summary>
/// Updates the channel with the information supplied. Only limited information can be updated
/// via this API. See the ChannelUpdateableModel for the fields that are updateable.
/// </summary>
/// <param name="channel">The channel to update</param>
/// <returns>The updated channel</returns>
public async Task <ChannelModel> UpdateChannel(ChannelModel channel)
{
Validator.ValidateVariable(channel, "channel");
// Need to strip out all of the non-updateable fields in order for the API to not return a 403 error
ChannelUpdateableModel updateableChannel = JSONSerializerHelper.Clone <ChannelUpdateableModel>(channel);
return(await this.PatchAsync <ChannelModel>("channels/" + channel.id, this.CreateContentFromObject(updateableChannel)));
}
private async void UserClient_OnMessageReceived(object sender, ChatMessagePacketModel message)
{
if (message != null && !string.IsNullOrEmpty(message.Message))
{
if (!string.IsNullOrEmpty(message.UserLogin) && message.UserLogin.Equals("jtv"))
{
if (Regex.IsMatch(message.Message, TwitchChatService.HostChatMessageRegexPattern))
{
Logger.Log(LogLevel.Debug, JSONSerializerHelper.SerializeToString(message));
string hoster = message.Message.Substring(0, message.Message.IndexOf(' '));
UserViewModel user = ChannelSession.Services.User.GetUserByUsername(hoster, StreamingPlatformTypeEnum.Twitch);
if (user == null)
{
UserModel twitchUser = await ChannelSession.TwitchUserConnection.GetNewAPIUserByLogin(hoster);
if (twitchUser != null)
{
user = await ChannelSession.Services.User.AddOrUpdateUser(twitchUser);
}
}
if (user != null)
{
EventTrigger trigger = new EventTrigger(EventTypeEnum.TwitchChannelHosted, user);
if (ChannelSession.Services.Events.CanPerformEvent(trigger))
{
foreach (CurrencyModel currency in ChannelSession.Settings.Currency.Values.ToList())
{
currency.AddAmount(user.Data, currency.OnHostBonus);
}
GlobalEvents.HostOccurred(user);
await ChannelSession.Services.Events.PerformEvent(trigger);
await ChannelSession.Services.Alerts.AddAlert(new AlertChatMessageViewModel(StreamingPlatformTypeEnum.Twitch, user, string.Format("{0} hosted the channel", user.Username), ChannelSession.Settings.AlertHostColor));
}
}
}
}
else
{
UserViewModel user = ChannelSession.Services.User.GetUserByTwitchID(message.UserID);
if (user == null)
{
UserModel twitchUser = await ChannelSession.TwitchUserConnection.GetNewAPIUserByLogin(message.UserLogin);
if (twitchUser != null)
{
user = await ChannelSession.Services.User.AddOrUpdateUser(twitchUser);
}
}
this.OnMessageOccurred(this, new TwitchChatMessageViewModel(message, user));
}
}
}
public static async Task SerializeToFile <T>(string filePath, T data)
{
string dataString = JSONSerializerHelper.SerializeToString(data);
if (!string.IsNullOrEmpty(dataString))
{
await FileSerializerHelper.fileService.SaveFile(filePath, dataString);
}
}
public override void DuplicateAction(ActionContainerControl actionContainer)
{
List <ActionBase> actions = new List <ActionBase>()
{
actionContainer.GetAction()
};
actions = JSONSerializerHelper.Clone <List <ActionBase> >(actions);
this.AddActionControlContainer(new ActionContainerControl(this.window, this, actions.First()));
}
private async void UserClient_OnUserNoticeReceived(object sender, ChatUserNoticePacketModel userNotice)
{
try
{
if (RaidUserNoticeMessageTypeID.Equals(userNotice.MessageTypeID))
{
UserViewModel user = ChannelSession.Services.User.GetUserByTwitchID(userNotice.UserID.ToString());
if (user == null)
{
user = new UserViewModel(userNotice);
}
user.SetTwitchChatDetails(userNotice);
EventTrigger trigger = new EventTrigger(EventTypeEnum.TwitchChannelRaided, user);
if (ChannelSession.Services.Events.CanPerformEvent(trigger))
{
ChannelSession.Settings.LatestSpecialIdentifiersData[SpecialIdentifierStringBuilder.LatestRaidUserData] = user.ID;
ChannelSession.Settings.LatestSpecialIdentifiersData[SpecialIdentifierStringBuilder.LatestRaidViewerCountData] = userNotice.RaidViewerCount;
foreach (CurrencyModel currency in ChannelSession.Settings.Currency.Values.ToList())
{
currency.AddAmount(user.Data, currency.OnHostBonus);
}
GlobalEvents.RaidOccurred(user, userNotice.RaidViewerCount);
trigger.SpecialIdentifiers["hostviewercount"] = userNotice.RaidViewerCount.ToString();
trigger.SpecialIdentifiers["raidviewercount"] = userNotice.RaidViewerCount.ToString();
await ChannelSession.Services.Events.PerformEvent(trigger);
await ChannelSession.Services.Alerts.AddAlert(new AlertChatMessageViewModel(StreamingPlatformTypeEnum.Twitch, user, string.Format("{0} raided with {1} viewers", user.Username, userNotice.RaidViewerCount), ChannelSession.Settings.AlertRaidColor));
}
}
else if (SubMysteryGiftUserNoticeMessageTypeID.Equals(userNotice.MessageTypeID) && userNotice.SubTotalGifted > 0)
{
if (ChannelSession.Services.Events.TwitchEventService != null)
{
await ChannelSession.Services.Events.TwitchEventService.AddMassGiftedSub(new TwitchMassGiftedSubEventModel(userNotice));
}
}
else if (SubGiftPaidUpgradeUserNoticeMessageTypeID.Equals(userNotice.MessageTypeID))
{
if (ChannelSession.Services.Events.TwitchEventService != null)
{
await ChannelSession.Services.Events.TwitchEventService.AddSub(new TwitchSubEventModel(userNotice));
}
}
}
catch (Exception ex)
{
Logger.ForceLog(LogLevel.Debug, JSONSerializerHelper.SerializeToString(userNotice));
Logger.Log(ex);
throw ex;
}
}
/// <summary>
/// Updates the specified MixPlay game version.
/// </summary>
/// <param name="version">The MixPlay game version to update</param>
/// <returns>The updated MixPlay game version</returns>
public async Task <MixPlayGameVersionModel> UpdateMixPlayGameVersion(MixPlayGameVersionModel version)
{
Validator.ValidateVariable(version, "version");
// Need to strip out all of the non-updateable fields in order for the API to not return a 403 error
MixPlayGameVersionUpdateableModel updateableVersion = JSONSerializerHelper.Clone <MixPlayGameVersionUpdateableModel>(version);
updateableVersion.controls = version.controls;
return(await this.PutAsync <MixPlayGameVersionModel>("interactive/versions/" + version.id, this.CreateContentFromObject(updateableVersion)));
}
private async Task <bool> ConnectSocket()
{
try
{
this.WebSocketConnected = false;
this.socket.OnConnected -= Socket_OnConnected;
this.socket.OnDisconnected -= Socket_OnDisconnected;
await this.socket.Disconnect();
this.socket.OnConnected += Socket_OnConnected;
this.socket.Listen("authenticated", () =>
{
this.WebSocketConnected = true;
});
this.socket.Listen($"channel:{this.channel.ID}:tip", async(data) =>
{
try
{
if (data != null)
{
RainmakerDonation donation = JSONSerializerHelper.DeserializeFromString <RainmakerDonation>(data.ToString());
if (donation != null && !string.IsNullOrEmpty(donation.Name) && donation.Amount >= 0)
{
await EventService.ProcessDonationEvent(EventTypeEnum.RainmakerDonation, donation.ToGenericDonation());
}
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
});
await this.socket.Connect("wss://rainmaker.gg");
for (int i = 0; i < 10 && !this.WebSocketConnected; i++)
{
await Task.Delay(1000);
}
if (this.WebSocketConnected)
{
this.socket.OnDisconnected += Socket_OnDisconnected;
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
return(this.WebSocketConnected);
}
public void SetCommands(IEnumerable <CommandModelBase> commands)
{
try
{
this.Data = JSONSerializerHelper.SerializeToString(commands);
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
public async Task LoadAllUserData()
{
if (!this.fullUserDataLoadOccurred)
{
this.fullUserDataLoadOccurred = true;
await ChannelSession.Services.Database.Read(this.DatabaseFilePath, "SELECT * FROM Users", (Action <Dictionary <string, object> >)((Dictionary <string, object> data) =>
{
this.SetUserData((UserDataModel)JSONSerializerHelper.DeserializeFromString <UserDataModel>((string)data[(string)"Data"].ToString()));
}));
}
}
private MethodPacket BuildUpdateScenesPacket(IEnumerable <MixPlayConnectedSceneModel> scenes)
{
Validator.ValidateList(scenes, "scenes");
MixPlayConnectedSceneCollectionModel collection = new MixPlayConnectedSceneCollectionModel();
foreach (MixPlayConnectedSceneModel scene in scenes)
{
// Need to strip out all of the non-updateable fields in order for the API to not return a 403 error
collection.scenes.Add(JSONSerializerHelper.Clone <MixPlayConnectedSceneModel>(scene));
}
return(new MethodParamsPacket("updateScenes", JObject.FromObject(collection)));
}
public async Task SendIssueReport(IssueReportModel report)
{
string content = JSONSerializerHelper.SerializeToString(report);
var response = await this.PostAsync("issuereport", new StringContent(content, Encoding.UTF8, "application/json"));
if (!response.IsSuccessStatusCode)
{
string resultContent = await response.Content.ReadAsStringAsync();
Logger.Log(resultContent);
}
}
public List <CommandModelBase> GetCommands()
{
try
{
return(JSONSerializerHelper.DeserializeFromString <List <CommandModelBase> >(this.Data));
}
catch (Exception ex)
{
Logger.Log(ex);
}
return(null);
}
protected override async Task ProcessReceivedPacket(string packetJSON)
{
try
{
DiscordWebSocketPacket packet = JSONSerializerHelper.DeserializeFromString <DiscordWebSocketPacket>(packetJSON);
this.lastSequenceNumber = packet.Sequence;
switch (packet.OPCodeType)
{
case DiscordWebSocketPacketTypeEnum.Other:
if (packet.IsReadyPacket)
{
this.BotUser = new DiscordUser((JObject)packet.Data["user"]);
this.sessionID = packet.Data["session_id"].ToString();
this.IsReady = true;
}
break;
case DiscordWebSocketPacketTypeEnum.Heartbeat:
break;
case DiscordWebSocketPacketTypeEnum.Hello:
this.heartbeatTime = (int)packet.Data["heartbeat_interval"];
JObject data = new JObject();
data["token"] = this.botToken;
data["large_threshold"] = 100;
JObject propertiesObj = new JObject();
propertiesObj["$device"] = "Mix It Up";
data["properties"] = propertiesObj;
DiscordWebSocketPacket identifyPacket = new DiscordWebSocketPacket()
{
OPCodeType = DiscordWebSocketPacketTypeEnum.Identify, Data = data
};
await this.Send(identifyPacket);
break;
case DiscordWebSocketPacketTypeEnum.HeartbeatAck:
break;
default:
break;
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
/// <summary>
/// Validates whether the specific JWT bearer token is valid and returns the payload of the token if successful.
/// </summary>
/// <param name="bearerToken">The authentication bearer token</param>
/// <param name="clientSecret">The client secret of the extension</param>
/// <param name="payload">The payload contained in the JWT bearer token</param>
/// <returns>An error message indicating why the validation failed, null if successful</returns>
public static string ValidateAuthenticationToken(string bearerToken, string clientSecret, out TwitchJWTTokenPayloadModel payload)
{
Validator.ValidateString(bearerToken, "bearerToken");
Validator.ValidateString(clientSecret, "clientSecret");
payload = null;
if (!string.IsNullOrEmpty(bearerToken))
{
bearerToken = bearerToken.Replace("Bearer ", "");
}
JwtSecurityTokenHandler tokenHandler = new JwtSecurityTokenHandler();
if (!tokenHandler.CanReadToken(bearerToken))
{
return("Invalid JWT token");
}
var validationParameters = new TokenValidationParameters
{
ValidateAudience = false,
ValidateIssuer = false,
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Convert.FromBase64String(clientSecret))
};
JwtSecurityToken token = null;
try
{
tokenHandler.ValidateToken(bearerToken, validationParameters, out SecurityToken validatedToken);
if (validatedToken != null)
{
token = (JwtSecurityToken)validatedToken;
}
}
catch (Exception ex)
{
return("Token validation failed - " + ex.ToString());
}
if (token != null && token.Payload != null)
{
payload = JSONSerializerHelper.DeserializeFromString <TwitchJWTTokenPayloadModel>(token.Payload.SerializeToJson());
if (payload != null && !string.IsNullOrEmpty(payload.channel_id) && !string.IsNullOrEmpty(payload.opaque_user_id))
{
return(null);
}
}
return("Mising or invalid payload");
}
private async Task PutAsync(string endpoint, object data)
{
try
{
using (AdvancedHttpClient client = new AdvancedHttpClient(MixItUpAPIEndpoint))
{
string content = JSONSerializerHelper.SerializeToString(data);
HttpResponseMessage response = await client.PutAsync(endpoint, new StringContent(content, Encoding.UTF8, "application/json"));
await this.ProcessResponseIfError(response);
}
}
catch (Exception ex) { Logger.Log(ex); }
}
private Guid DuplicateCommand(Guid id)
{
if (id != Guid.Empty)
{
CustomCommandModel command = (CustomCommandModel)ChannelSession.Settings.GetCommand(id);
if (command != null)
{
command = JSONSerializerHelper.DeserializeFromString <CustomCommandModel>(JSONSerializerHelper.SerializeToString(command));
command.ID = Guid.NewGuid();
ChannelSession.Settings.SetCommand(command);
return(command.ID);
}
}
return(Guid.Empty);
}
/// <summary>
/// Processes a JSON packet received from the server.
/// </summary>
/// <param name="packet">The packet JSON</param>
/// <returns>An awaitable Task</returns>
protected override Task ProcessReceivedPacket(string packet)
{
List <JToken> packetJTokens = new List <JToken>();
JToken packetJToken = JToken.Parse(packet);
if (packetJToken is JArray)
{
foreach (JToken t in (JArray)packetJToken)
{
packetJTokens.Add(t);
}
}
else
{
packetJTokens.Add(packetJToken);
}
foreach (JToken token in packetJTokens)
{
WebSocketPacket webSocketPacket = token.ToObject <WebSocketPacket>();
string data = JSONSerializerHelper.SerializeToString(token);
this.OnPacketReceivedOccurred?.Invoke(this, webSocketPacket);
if (webSocketPacket.type.Equals("method"))
{
MethodPacket methodPacket = JsonConvert.DeserializeObject <MethodPacket>(data);
this.SendSpecificPacket(methodPacket, this.OnMethodOccurred);
}
else if (webSocketPacket.type.Equals("reply"))
{
ReplyPacket replyPacket = JsonConvert.DeserializeObject <ReplyPacket>(data);
if (this.replyIDListeners.ContainsKey(replyPacket.id))
{
this.replyIDListeners[replyPacket.id] = replyPacket;
}
this.SendSpecificPacket(replyPacket, this.OnReplyOccurred);
}
else if (webSocketPacket.type.Equals("event"))
{
EventPacket eventPacket = JsonConvert.DeserializeObject <EventPacket>(data);
this.SendSpecificPacket(eventPacket, this.OnEventOccurred);
}
}
return(Task.FromResult(0));
}
public async Task Send(WebSocketPacket packet)
{
try
{
foreach (WebSocketServerBase webSocketServer in this.webSocketServers)
{
Logger.Log(LogLevel.Debug, "Sending Web Socket Packet - " + JSONSerializerHelper.SerializeToString(packet));
await webSocketServer.Send(packet);
}
}
catch (Exception ex)
{
Logger.Log(ex);
}
}
private async Task PatchAsync(string endpoint, object data)
{
try
{
using (AdvancedHttpClient client = new AdvancedHttpClient(MixItUpAPIEndpoint))
{
string content = JSONSerializerHelper.SerializeToString(data);
HttpRequestMessage message = new HttpRequestMessage(new HttpMethod("PATCH"), endpoint);
message.Content = new StringContent(content, Encoding.UTF8, "application/json");
HttpResponseMessage response = await client.SendAsync(message);
await this.ProcessResponseIfError(response);
}
}
catch (Exception ex) { Logger.Log(ex); }
}
/// <summary>
/// Processes the webhook request sent from Twitch.
/// </summary>
/// <typeparam name="T">The type of data contained in the webhook request</typeparam>
/// <param name="request">The Http request made</param>
/// <param name="secret">The optional secret used for request verification</param>
/// <returns>The webhook result</returns>
public static async Task <WebhookResultModel <T> > GetWebhookResult <T>(HttpRequest request, string secret = null)
{
string headerSignature = null;
if (request.Headers.ContainsKey("X-Hub-Signature"))
{
headerSignature = request.Headers["X-Hub-Signature"];
headerSignature = headerSignature.Split('=').LastOrDefault();
}
long headerContentLength = request.ContentLength.GetValueOrDefault();
string body = string.Empty;
long bodyContentLength = 0;
string bodySignature = null;
using (StreamReader reader = new StreamReader(request.Body))
{
body = await reader.ReadToEndAsync();
}
Dictionary <string, string> queryParameters = new Dictionary <string, string>();
foreach (var kvp in request.Query)
{
queryParameters[kvp.Key] = kvp.Value;
}
WebhookDataWrapperModel <T> dataWrapper = null;
if (!string.IsNullOrEmpty(body))
{
bodyContentLength = body.Length;
if (!string.IsNullOrEmpty(secret))
{
byte[] secretBytes = Encoding.UTF8.GetBytes(secret);
using (HMACSHA256 hmacSha256 = new HMACSHA256(secretBytes))
{
byte[] hashBytes = hmacSha256.ComputeHash(Encoding.UTF8.GetBytes(body));
bodySignature = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();
}
}
dataWrapper = JSONSerializerHelper.DeserializeFromString <WebhookDataWrapperModel <T> >(body);
}
return(new WebhookResultModel <T>(headerSignature, headerContentLength, bodySignature, bodyContentLength, queryParameters, (dataWrapper != null) ? dataWrapper.data : new List <T>()));
}
