/// <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)); }
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); } }
/// <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 })); }
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) } })); } }
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); } }
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; } }
public void SetCommands(IEnumerable <CommandModelBase> commands) { try { this.Data = JSONSerializerHelper.SerializeToString(commands); } catch (Exception ex) { Logger.Log(ex); } }
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); } }
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); } }
/// <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)); }
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); } }
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); } }
public async Task <VTubeStudioWebSocketResponsePacket> SendAndReceive(VTubeStudioWebSocketRequestPacket packet, int delaySeconds = 5) { Logger.Log(LogLevel.Debug, "VTube Studio Packet Sent - " + JSONSerializerHelper.SerializeToString(packet)); this.responses.Remove(packet.requestID); await this.Send(JSONSerializerHelper.SerializeToString(packet)); int cycles = delaySeconds * 10; for (int i = 0; i < cycles && !this.responses.ContainsKey(packet.requestID); i++) { await Task.Delay(100); } this.responses.TryGetValue(packet.requestID, out VTubeStudioWebSocketResponsePacket response); return(response); }
private static async void Chat_OnPacketReceived(object sender, Base.Models.Clients.Chat.ChatRawPacketModel packet) { if (!packet.Command.Equals("PING") && !packet.Command.Equals(ChatMessagePacketModel.CommandID) && !packet.Command.Equals(ChatUserJoinPacketModel.CommandID) && !packet.Command.Equals(ChatUserLeavePacketModel.CommandID)) { System.Console.WriteLine("PACKET: " + packet.Command); await semaphore.WaitAndRelease(async() => { using (StreamWriter writer = new StreamWriter(File.Open("Packets.txt", FileMode.Append))) { await writer.WriteLineAsync(JSONSerializerHelper.SerializeToString(packet)); await writer.WriteLineAsync(); await writer.FlushAsync(); } }); } }
public async Task SaveDatabaseData() { 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.GetAddedChangedValues(); await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "REPLACE INTO Users(ID, TwitchID, TwitchUsername, YouTubeID, YouTubeUsername, FacebookID, FacebookUsername, TrovoID, TrovoUsername, GlimeshID, GlimeshUsername, Data) " + "VALUES($ID, $TwitchID, $TwitchUsername, $YouTubeID, $YouTubeUsername, $FacebookID, $FacebookUsername, $TrovoID, $TrovoUsername, $GlimeshID, $GlimeshUsername, $Data)", changedUsers.Select(u => new Dictionary <string, object>() { { "$ID", u.ID.ToString() }, { "$TwitchID", u.TwitchID }, { "$TwitchUsername", u.TwitchUsername }, { "$YouTubeID", null }, { "$YouTubeUsername", null }, { "$FacebookID", null }, { "$FacebookUsername", null }, { "$TrovoID", null }, { "$TrovoUsername", null }, { "$GlimeshID", null }, { "$GlimeshUsername", null }, { "$Data", JSONSerializerHelper.SerializeToString(u) } })); List <Guid> removedCommands = new List <Guid>(); await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "DELETE FROM Commands WHERE ID = $ID", this.Commands.GetRemovedValues().Select(id => new Dictionary <string, object>() { { "$ID", id.ToString() } })); await ChannelSession.Services.Database.BulkWrite(this.DatabaseFilePath, "REPLACE INTO Commands(ID, TypeID, Data) VALUES($ID, $TypeID, $Data)", this.Commands.GetAddedChangedValues().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, Quote, GameName, DateTime) VALUES($ID, $Quote, $GameName, $DateTime)", this.Quotes.GetAddedChangedValues().Select(q => new Dictionary <string, object>() { { "$ID", q.ID.ToString() }, { "$Quote", q.Quote }, { "$GameName", q.GameName }, { "$DateTime", q.DateTime.ToString() } })); }
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 hosterUsername = message.Message.Substring(0, message.Message.IndexOf(' ')); UserViewModel user = await ChannelSession.Services.User.GetUserFullSearch(StreamingPlatformTypeEnum.Twitch, userID : null, hosterUsername); if (user != null) { await ChannelSession.Services.User.AddOrUpdateActiveUser(user); CommandParametersModel parameters = new CommandParametersModel(user); if (ChannelSession.Services.Events.CanPerformEvent(EventTypeEnum.TwitchChannelHosted, parameters)) { foreach (CurrencyModel currency in ChannelSession.Settings.Currency.Values.ToList()) { currency.AddAmount(user.Data, currency.OnHostBonus); } GlobalEvents.HostOccurred(user); await ChannelSession.Services.Events.PerformEvent(EventTypeEnum.TwitchChannelHosted, parameters); await ChannelSession.Services.Alerts.AddAlert(new AlertChatMessageViewModel(StreamingPlatformTypeEnum.Twitch, user, string.Format("{0} hosted the channel", user.FullDisplayName), ChannelSession.Settings.AlertHostColor)); } } } } else { UserViewModel user = await ChannelSession.Services.User.GetUserFullSearch(StreamingPlatformTypeEnum.Twitch, message.UserID, message.UserLogin); this.OnMessageOccurred(this, new TwitchChatMessageViewModel(message, user)); } } }
public IEnumerable <T> GetChangedValues() { Dictionary <T, int> currentHashes = new Dictionary <T, int>(); foreach (T value in this.ToList()) { currentHashes[value] = JSONSerializerHelper.SerializeToString(value).GetHashCode(); } List <T> results = new List <T>(); lock (valuesUpdateLock) { foreach (var current in currentHashes) { if (this.changedValues.ContainsKey(current.Key) && this.changedValues[current.Key] != current.Value) { results.Add(current.Key); } this.changedValues[current.Key] = current.Value; } } return(results); }
private async Task <T> PostAsyncWithResult <T>(string endpoint, object data) { try { using (AdvancedHttpClient client = new AdvancedHttpClient(MixItUpAPIEndpoint)) { string content = JSONSerializerHelper.SerializeToString(data); HttpResponseMessage response = await client.PostAsync(endpoint, new StringContent(content, Encoding.UTF8, "application/json")); if (response.StatusCode == HttpStatusCode.OK) { string resultContent = await response.Content.ReadAsStringAsync(); return(JSONSerializerHelper.DeserializeFromString <T>(resultContent)); } else { await this.ProcessResponseIfError(response); } } } catch (Exception ex) { Logger.Log(ex); } return(default(T)); }
/// <summary> /// Sends a chat message to the specified channel from the extension. /// </summary> /// <param name="clientID">The client ID of the extension</param> /// <param name="clientSecret">The client secret of the extension</param> /// <param name="ownerID">The owner user ID of the extension</param> /// <param name="version">The version of the extension</param> /// <param name="channelID">The channel ID to broadcast to</param> /// <param name="message">The message to send</param> /// <returns>Whether the chat message send was successful. Throws a HttpRestRequestException in the event of failed request</returns> public static async Task <bool> SendChatMessage(string clientID, string clientSecret, string ownerID, string version, string channelID, string message) { Validator.ValidateString(clientID, "clientID"); Validator.ValidateString(clientSecret, "clientSecret"); Validator.ValidateString(ownerID, "ownerID"); Validator.ValidateString(version, "version"); Validator.ValidateString(channelID, "channelID"); Validator.ValidateString(message, "message"); using (AdvancedHttpClient client = TwitchExtensionService.GetHttpClient(clientID, clientSecret, ownerID, channelID)) { HttpResponseMessage response = await client.PostAsync($"https://api.twitch.tv/extensions/{clientID}/{version}/channels/{channelID}/chat", AdvancedHttpClient.CreateContentFromString(JSONSerializerHelper.SerializeToString(new ExtensionChatMessageModel(message)))); if (response.IsSuccessStatusCode) { return(true); } else { throw new HttpRestRequestException(response); } } }
private void PubSub_OnMessageReceived(object sender, PubSubMessagePacketModel packet) { Logger.Log(LogLevel.Debug, string.Format("PUB SUB MESSAGE: {0} {1} ", packet.type, packet.message)); Logger.Log(LogLevel.Debug, JSONSerializerHelper.SerializeToString(packet)); }
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); }
private void Client_OnPacketReceived(object sender, ChatRawPacketModel packet) { if (!TwitchChatService.ExcludedDiagnosticPacketLogging.Contains(packet.Command)) { if (ChannelSession.AppSettings.DiagnosticLogging) { Logger.Log(LogLevel.Debug, string.Format("Twitch Client Packet Received: {0}", JSONSerializerHelper.SerializeToString(packet))); } } }
public async Task BulkWrite(string databaseFilePath, string commandString, IEnumerable <Dictionary <string, object> > parameters) { await this.EstablishConnection(databaseFilePath, async (connection) => { for (int i = 0; i < parameters.Count(); i += WindowsDatabaseService.MaxBulkInsertRows) { var rowsToInsert = parameters.Skip(i).Take(WindowsDatabaseService.MaxBulkInsertRows); using (SQLiteTransaction transaction = connection.BeginTransaction()) { using (SQLiteCommand command = new SQLiteCommand(commandString, connection)) { foreach (Dictionary <string, object> rowParameters in rowsToInsert) { try { foreach (var kvp in rowParameters) { command.Parameters.Add(new SQLiteParameter(kvp.Key, value: kvp.Value)); } Logger.Log(LogLevel.Debug, string.Format("SQLite Query: {0} - {1}", commandString, JSONSerializerHelper.SerializeToString(rowParameters))); await command.ExecuteNonQueryAsync(); command.Parameters.Clear(); } catch (Exception ex) { Logger.Log(ex); } } } transaction.Commit(); } } }); }
/// <summary> /// Logs a YouTube service response /// </summary> /// <typeparam name="T">The type of the request</typeparam> /// <param name="request">The request to log</param> /// <param name="response">The response to log</param> protected void LogResponse <T>(YouTubePartnerBaseServiceRequest <T> request, IDirectResponseSchema response) { if (Logger.Level == LogLevel.Debug) { Logger.Log(LogLevel.Debug, "Rest API Request Complete: " + request.RestPath + " - " + JSONSerializerHelper.SerializeToString(response)); } }
/// <summary> /// Logs a YouTube service request. /// </summary> /// <typeparam name="T">The type of the request</typeparam> /// <param name="request">The request to log</param> protected void LogRequest <T>(YouTubePartnerBaseServiceRequest <T> request) { if (Logger.Level == LogLevel.Debug) { Logger.Log(LogLevel.Debug, "Rest API Request Sent: " + request.RestPath + " - " + JSONSerializerHelper.SerializeToString(request, propertiesToIgnore: requestPropertiesToIgnore)); } }
/// <summary> /// Sends the specified packet. /// </summary> /// <param name="packet">The packet to send</param> /// <returns>An awaitable Task</returns> protected async Task Send(ChatPacketModel packet) { await this.Send(JSONSerializerHelper.SerializeToString(packet)); }
private async Task Send(PubSubPacketModel packet) { await this.Send(JSONSerializerHelper.SerializeToString(packet)); }
/// <summary> /// Sends a ping packet. /// </summary> /// <returns>An awaitable Task</returns> public async Task Ping() { await this.Send(JSONSerializerHelper.SerializeToString(new { type = "PING" })); }
/// <summary> /// Sends a broadcast to PubSub for the extension. /// </summary> /// <param name="clientID">The client ID of the extension</param> /// <param name="clientSecret">The client secret of the extension</param> /// <param name="ownerID">The owner user ID of the extension</param> /// <param name="channelID">The channel ID to broadcast to</param> /// <param name="data">The data to broadcast</param> /// <returns>Whether the broadcast was successful or not. Throws a HttpRestRequestException in the event of failed request</returns> public static async Task <bool> SendBroadcast(string clientID, string clientSecret, string ownerID, string channelID, object data) { Validator.ValidateString(clientID, "clientID"); Validator.ValidateString(clientSecret, "clientSecret"); Validator.ValidateString(ownerID, "ownerID"); Validator.ValidateString(channelID, "channelID"); Validator.ValidateVariable(data, "data"); using (AdvancedHttpClient client = TwitchExtensionService.GetHttpClient(clientID, clientSecret, ownerID, channelID)) { HttpResponseMessage response = await client.PostAsync("https://api.twitch.tv/extensions/message/" + channelID, AdvancedHttpClient.CreateContentFromString(JSONSerializerHelper.SerializeToString(new BroadcastBodyModel(data)))); if (response.IsSuccessStatusCode) { return(true); } else { throw new HttpRestRequestException(response); } } }