/// <summary>
/// Updates the specified broadcaster's channel with the specified tags.
/// </summary>
/// <param name="broadcaster">The broadcaster to get stream tags for.</param>
/// <param name="tags">The set of tags to update with</param>
/// <returns>An awaitable Task</returns>
public async Task UpdateStreamTags(UserModel broadcaster, IEnumerable <TagModel> tags = null)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
List <string> tagIDs = (tags != null) ? tags.Select(t => t.tag_id).ToList() : new List <string>();
await this.PutAsync("streams/tags?broadcaster_id=" + broadcaster.id, AdvancedHttpClient.CreateContentFromObject(new { tag_ids = tagIDs }));
}
public override async Task <IEnumerable <StreamingPlatformStatusModel> > GetCurrentIncidents()
{
List <StreamingPlatformStatusModel> incidents = new List <StreamingPlatformStatusModel>();
try
{
StatusPageUnresolvedIncidents unresolvedIncidents = null;
using (AdvancedHttpClient client = new AdvancedHttpClient())
{
unresolvedIncidents = await client.GetAsync <StatusPageUnresolvedIncidents>(this.statusFeedLink);
}
if (unresolvedIncidents != null && unresolvedIncidents.incidents != null && unresolvedIncidents.incidents.Count > 0)
{
foreach (StatusPageUnresolvedIncident incident in unresolvedIncidents.incidents)
{
if (incident.incident_updates != null && incident.incident_updates.Count > 0)
{
StatusPageUnresolvedIncidentUpdate latestUpdate = incident.incident_updates.OrderByDescending(i => i.updated_at).FirstOrDefault();
if (latestUpdate != null)
{
incidents.Add(new StreamingPlatformStatusModel(this.platform, incident.name, latestUpdate.body, latestUpdate.updated_at, incident.shortlink));
}
}
}
}
return(incidents);
}
catch (Exception ex) { Logger.Log(ex); }
return(incidents);
}
public static void SetBasicClientIDClientSecretAuthorizationHeader(this AdvancedHttpClient client, string clientID, string clientSecret)
{
string authorizationValue = string.Format("{0}:{1}", clientID, clientSecret);
byte[] authorizationBytes = System.Text.Encoding.UTF8.GetBytes(authorizationValue);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", Convert.ToBase64String(authorizationBytes));
}
public override async Task <Result> Connect()
{
try
{
string authorizationCode = await this.ConnectViaOAuthRedirect(string.Format(StreamlabsService.AuthorizationUrl, StreamlabsService.ClientID));
if (!string.IsNullOrEmpty(authorizationCode))
{
JObject payload = new JObject();
payload["grant_type"] = "authorization_code";
payload["client_id"] = StreamlabsService.ClientID;
payload["client_secret"] = ChannelSession.Services.Secrets.GetSecret("StreamlabsSecret");
payload["code"] = authorizationCode;
payload["redirect_uri"] = OAuthExternalServiceBase.DEFAULT_OAUTH_LOCALHOST_URL;
this.token = await this.PostAsync <OAuthTokenModel>("token", AdvancedHttpClient.CreateContentFromObject(payload), autoRefreshToken : false);
if (this.token != null)
{
token.authorizationCode = authorizationCode;
return(await this.InitializeInternal());
}
}
}
catch (Exception ex)
{
Logger.Log(ex);
return(new Result(ex));
}
return(new Result(false));
}
/// <summary>
/// Sets the configuration data
/// </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="segment">The segment type of the configuration</param>
/// <param name="version">The version for the configuration</param>
/// <param name="data">The data to set for the configuration</param>
/// <returns>Whether the broadcast was successful or not. Throws a HttpRestRequestException in the event of failed request</returns>
public static async Task <bool> SetConfiguration(string clientID, string clientSecret, string ownerID, string channelID, string segment, string version, object data)
{
Validator.ValidateString(clientID, "clientID");
Validator.ValidateString(clientSecret, "clientSecret");
Validator.ValidateString(ownerID, "ownerID");
Validator.ValidateString(segment, "segment");
Validator.ValidateString(version, "version");
Validator.ValidateVariable(data, "data");
using (AdvancedHttpClient client = TwitchExtensionService.GetHttpClient(clientID, clientSecret, ownerID, channelID))
{
ConfigurationModel configuration = (ConfigurationModel.GlobalConfigurationSegmentValue.Equals(segment)) ?
new ConfigurationModel(segment, version, JSONSerializerHelper.SerializeToString(data)) :
new ChannelConfigurationModel(channelID, segment, version, JSONSerializerHelper.SerializeToString(data));
HttpResponseMessage response = await client.PutAsync($"https://api.twitch.tv/extensions/{clientID}/configurations/",
AdvancedHttpClient.CreateContentFromString(JSONSerializerHelper.SerializeToString(configuration)));
if (response.IsSuccessStatusCode)
{
return(true);
}
else
{
throw new HttpRestRequestException(response);
}
}
}
/// <summary>
/// Gets the global configuration data.
/// </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>
/// <returns>The global configuration data for the extension</returns>
public static async Task <ConfigurationModel> GetGlobalConfiguration(string clientID, string clientSecret, string ownerID)
{
Validator.ValidateString(clientID, "clientID");
Validator.ValidateString(clientSecret, "clientSecret");
Validator.ValidateString(ownerID, "ownerID");
using (AdvancedHttpClient client = TwitchExtensionService.GetHttpClient(clientID, clientSecret, ownerID, null))
{
HttpResponseMessage response = await client.GetAsync($"https://api.twitch.tv/extensions/{clientID}/configurations/segments/global");
if (response.IsSuccessStatusCode)
{
JObject jobj = await response.ProcessJObjectResponse();
if (jobj != null && jobj.Count > 0)
{
ConfigurationResultModel result = jobj.Values().First().ToObject <ConfigurationResultModel>();
if (result != null)
{
return(new ConfigurationModel(result));
}
}
return(null);
}
else
{
return(null);
}
}
}
/// <summary>
/// Updates the specified channel.
/// </summary>
/// <param name="id">The ID of the channel</param>
/// <param name="title">The title of the channel</param>
/// <param name="categoryID">The ID of the category for the channel</param>
/// <param name="langaugeCode">The language code for the channel</param>
/// <param name="audience">The viewing audience for the channel</param>
/// <returns>Whether the update was successful</returns>
public async Task <bool> UpdateChannel(string id, string title = null, string categoryID = null, string langaugeCode = null, ChannelAudienceTypeEnum?audience = null)
{
Validator.ValidateString(id, "id");
JObject jobj = new JObject();
jobj["channel_id"] = id;
if (!string.IsNullOrEmpty(title))
{
jobj["live_title"] = title;
}
if (!string.IsNullOrEmpty(categoryID))
{
jobj["category_id"] = categoryID;
}
if (!string.IsNullOrEmpty(langaugeCode))
{
jobj["language_code"] = langaugeCode;
}
if (audience != null)
{
jobj["audi_type"] = audience.ToString();
}
HttpResponseMessage response = await this.PostAsync("channels/update", AdvancedHttpClient.CreateContentFromObject(jobj));
return(response.IsSuccessStatusCode);
}
protected override async Task <AdvancedHttpClient> GetHttpClient(bool autoRefreshToken = true)
{
AdvancedHttpClient client = await base.GetHttpClient(autoRefreshToken);
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bot", this.botToken);
return(client);
}
/// <summary>
/// Processes the webhook topic request
/// </summary>
/// <param name="callback">URL where notifications will be delivered.</param>
/// <param name="mode"></param>
/// <param name="topic">URL for the topic to subscribe to or unsubscribe from. topic maps to a new Twitch API endpoint.</param>
/// <param name="lease_seconds">Number of seconds until the subscription expires. Default: 0. Maximum: 864000.</param>
/// <param name="secret">Secret used to sign notification payloads. The X-Hub-Signature header is generated by sha256(secret, notification_bytes).</param>
/// <returns>True if the request was successfully sent to Twitch, otherise false</returns>
private async Task <bool> processWebhookTopicRequest(string callback, string mode, string topic, int lease_seconds, string secret)
{
var hubObject = new WebhookHubModel()
{
callback = callback, mode = mode, topic = topic, lease_seconds = lease_seconds.ToString(), secret = secret
};
try
{
var response = await this.PostAsync("webhooks/hub", AdvancedHttpClient.CreateContentFromObject(hubObject));
if (response.IsSuccessStatusCode)
{
return(true);
}
else
{
return(false);
}
}
catch (Exception)
{
return(false);
}
}
public async Task <DiscordMessage> CreateMessage(DiscordChannel channel, string message, string filePath)
{
try
{
DiscordMessage messageObj = new DiscordMessage()
{
Content = message
};
var messageContent = AdvancedHttpClient.CreateContentFromObject(messageObj);
var multiPart = new MultipartFormDataContent();
multiPart.Add(messageContent, "\"payload_json\"");
if (!string.IsNullOrEmpty(filePath))
{
byte[] bytes = await ChannelSession.Services.FileService.ReadFileAsBytes(filePath);
if (bytes != null && bytes.Length > 0)
{
var fileContent = new ByteArrayContent(bytes);
string fileName = System.IO.Path.GetFileName(filePath);
multiPart.Add(fileContent, "\"file\"", $"\"{fileName}\"");
}
}
return(await this.PostAsync <DiscordMessage>("channels/" + channel.ID + "/messages", multiPart));
}
catch (Exception ex) { Logger.Log(ex); }
return(null);
}
private async Task DownloadFrankerFaceZEmotes(string channelName = null)
{
try
{
using (AdvancedHttpClient client = new AdvancedHttpClient())
{
JObject jobj = await client.GetJObjectAsync((!string.IsNullOrEmpty(channelName))? "https://api.frankerfacez.com/v1/room/" + channelName : "https://api.frankerfacez.com/v1/set/global");
if (jobj != null && jobj.ContainsKey("sets"))
{
JObject setsJObj = (JObject)jobj["sets"];
foreach (var kvp in setsJObj)
{
JObject setJObj = (JObject)kvp.Value;
if (setJObj != null && setJObj.ContainsKey("emoticons"))
{
JArray emoticonsJArray = (JArray)setJObj["emoticons"];
foreach (FrankerFaceZEmoteModel emote in emoticonsJArray.ToTypedArray <FrankerFaceZEmoteModel>())
{
this.frankerFaceZEmotes[emote.name] = emote;
}
}
}
}
}
}
catch (Exception ex) { Logger.Log(ex); }
}
/// <summary>
/// Gets the configuration data for the specified channel.
/// </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>
/// <returns>The channel-specific configuration data for the extension</returns>
public static async Task <IEnumerable <ChannelConfigurationModel> > GetChannelConfiguration(string clientID, string clientSecret, string ownerID, string channelID)
{
Validator.ValidateString(clientID, "clientID");
Validator.ValidateString(clientSecret, "clientSecret");
Validator.ValidateString(ownerID, "ownerID");
Validator.ValidateString(channelID, "channelID");
using (AdvancedHttpClient client = TwitchExtensionService.GetHttpClient(clientID, clientSecret, ownerID, channelID))
{
HttpResponseMessage response = await client.GetAsync($"https://api.twitch.tv/extensions/{clientID}/configurations/segments/broadcaster?channel_id={channelID}");
if (response.IsSuccessStatusCode)
{
List <ChannelConfigurationModel> results = new List <ChannelConfigurationModel>();
JObject jobj = await response.ProcessJObjectResponse();
if (jobj != null)
{
foreach (var kvp in jobj)
{
ConfigurationResultModel result = kvp.Value.ToObject <ConfigurationResultModel>();
if (result != null)
{
results.Add(new ChannelConfigurationModel(result));
}
}
}
return(results);
}
else
{
return(new List <ChannelConfigurationModel>());
}
}
}
public async Task SendTrigger(string eventName, Dictionary <string, string> values)
{
try
{
using (AdvancedHttpClient client = new AdvancedHttpClient())
{
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>
/// Sets the communities for a channel.
/// </summary>
/// <param name="channel">The channel to set communities for</param>
/// <param name="communities">The communities to set</param>
/// <returns>An awaitable Task</returns>
public async Task SetChannelCommunities(ChannelModel channel, IEnumerable <CommunityModel> communities)
{
Validator.ValidateVariable(channel, "channel");
JObject content = new JObject();
content["community_ids"] = new JArray(communities.Select(c => c.id).ToList());
await this.PutAsync("channels/" + channel.id + "/communities", AdvancedHttpClient.CreateContentFromObject(content));
}
protected override async Task <AdvancedHttpClient> GetHttpClient(bool autoRefreshToken = true)
{
AdvancedHttpClient client = await base.GetHttpClient(autoRefreshToken);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("text/xml"));
return(client);
}
protected override Task <AdvancedHttpClient> GetHttpClient(bool autoRefreshToken = true)
{
AdvancedHttpClient httpClient = new AdvancedHttpClient(PixelChatService.BaseAddress);
httpClient.DefaultRequestHeaders.Add("x-api-key", this.token.accessToken);
httpClient.DefaultRequestHeaders.Add("x-application", "Mix It Up");
return(Task.FromResult(httpClient));
}
protected override async Task <AdvancedHttpClient> GetHttpClient(bool autoRefreshToken = true)
{
AdvancedHttpClient client = await base.GetHttpClient(autoRefreshToken);
client.DefaultRequestHeaders.Add("x-app-id", JustGivingService.ClientID);
client.DefaultRequestHeaders.Add("x-application-key", ChannelSession.Services.Secrets.GetSecret("JustGivingSecret"));
return(client);
}
public static async Task DeleteAsync(string path)
{
AdvancedHttpClient client = new AdvancedHttpClient
{
BaseAddress = new Uri(BaseUri)
};
await client.DeleteAsync(path);
}
/// <summary>
/// Processes the webhook topic request
/// </summary>
/// <param name="callback">URL where notifications will be delivered.</param>
/// <param name="mode">Whether the request is a subscribing or unsubscribing</param>
/// <param name="topic">URL for the topic to subscribe to or unsubscribe from. topic maps to a new Twitch API endpoint.</param>
/// <param name="lease_seconds">Number of seconds until the subscription expires. Default: 0. Maximum: 864000.</param>
/// <param name="secret">Secret used to sign notification payloads. The X-Hub-Signature header is generated by sha256(secret, notification_bytes).</param>
/// <returns>An awaitable task</returns>
/// <exception cref="HttpRestRequestException">Throw in the event of a failed request</exception>
private async Task processWebhookTopicRequest(string callback, string mode, string topic, int lease_seconds, string secret)
{
HttpResponseMessage response = await this.PostAsync("webhooks/hub", AdvancedHttpClient.CreateContentFromObject(new WebhookSubscriptionRegistrationModel(callback, mode, topic, lease_seconds, secret)));
if (!response.IsSuccessStatusCode)
{
throw new HttpRestRequestException(response);
}
}
/// <summary>
/// Sends a message to the currently authenticated channel.
/// </summary>
/// <param name="message">The message to send</param>
/// <returns>An awaitable Task</returns>
public async Task SendMessage(string message)
{
Validator.ValidateString(message, "message");
JObject jobj = new JObject();
jobj["content"] = message;
await this.PostAsync("chat/send", AdvancedHttpClient.CreateContentFromObject(jobj));
}
private static AdvancedHttpClient GetHttpClient(string clientID, string clientSecret, string ownerID, string channelID)
{
AdvancedHttpClient client = new AdvancedHttpClient();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
client.DefaultRequestHeaders.Add("Client-ID", clientID);
client.DefaultRequestHeaders.Add("Authorization", "Bearer " + TwitchExtensionService.CreateAuthenticationToken(clientSecret, ownerID, channelID));
return(client);
}
protected override async Task <AdvancedHttpClient> GetHttpClient(bool autoRefreshToken = true)
{
AdvancedHttpClient client = await base.GetHttpClient(autoRefreshToken);
if (this.token != null)
{
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("OAuth", this.token.accessToken);
}
return(client);
}
/// <summary>
/// Gets the HttpClient using the OAuth for the connection of this service.
/// </summary>
/// <param name="autoRefreshToken">Whether to automatically refresh the OAuth token or not if it has to be</param>
/// <returns>The HttpClient for the connection</returns>
protected override async Task <AdvancedHttpClient> GetHttpClient(bool autoRefreshToken = true)
{
AdvancedHttpClient client = await base.GetHttpClient(autoRefreshToken);
if (!string.IsNullOrEmpty(this.clientID))
{
client.DefaultRequestHeaders.Add("Client-ID", this.clientID);
}
return(client);
}
/// <summary>
/// Gets the channel matching the specified username.
/// </summary>
/// <param name="username">The channel username to search for</param>
/// <returns>The matching channel</returns>
public async Task <ChannelModel> GetChannelByUsername(string username)
{
Validator.ValidateString(username, "username");
JObject requestParameters = new JObject();
requestParameters["username"] = username;
return(await this.PostAsync <ChannelModel>("channels/id", AdvancedHttpClient.CreateContentFromObject(requestParameters)));
}
/// <summary>
/// Gets the channel matching the specified ID.
/// </summary>
/// <param name="id">The channel ID to search for</param>
/// <returns>The matching channel</returns>
public async Task <ChannelModel> GetChannelByID(string id)
{
Validator.ValidateString(id, "id");
JObject requestParameters = new JObject();
requestParameters["channel_id"] = id;
return(await this.PostAsync <ChannelModel>("channels/id", AdvancedHttpClient.CreateContentFromObject(requestParameters)));
}
private async Task DeleteAsync(string endpoint)
{
try
{
using (AdvancedHttpClient client = new AdvancedHttpClient(MixItUpAPIEndpoint))
{
await client.DeleteAsync(endpoint);
}
}
catch (Exception ex) { Logger.Log(ex); }
}
public static async Task PostAsync(string path, object body)
{
AdvancedHttpClient client = new AdvancedHttpClient
{
BaseAddress = new Uri(BaseUri)
};
var json = JsonConvert.SerializeObject(body);
HttpContent content = new StringContent(json, UnicodeEncoding.UTF8, "application/json");
await client.PostAsync(path, content);
}
/// <summary>
/// Gets the HttpClient using the OAuth for the connection of this service.
/// </summary>
/// <param name="autoRefreshToken">Whether to automatically refresh the OAuth token or not if it has to be</param>
/// <returns>The HttpClient for the connection</returns>
protected override async Task <AdvancedHttpClient> GetHttpClient(bool autoRefreshToken = true)
{
AdvancedHttpClient client = new AdvancedHttpClient(this.GetBaseAddress());
OAuthTokenModel token = await this.GetOAuthToken(autoRefreshToken);
if (token != null)
{
client = new AdvancedHttpClient(this.GetBaseAddress(), "OAuth", token.accessToken);
}
client.DefaultRequestHeaders.Add("Client-ID", this.clientID);
return(client);
}
/// <summary>
/// Performs a POST REST request using the provided request URI for paged cursor data.
/// </summary>
/// <param name="requestUri">The request URI to use</param>
/// <param name="maxResults">The maximum number of results. Will be either that amount or slightly more</param>
/// <param name="maxLimit">The maximum limit of results that can be returned in a single request</param>
/// <param name="parameters">Optional parameters to include in the request</param>
/// <returns>A type-casted object of the contents of the response</returns>
public async Task <IEnumerable <T> > PostPagedTokenAsync <T>(string requestUri, int maxResults = 1, int maxLimit = -1, Dictionary <string, object> parameters = null) where T : PageDataResponseModel
{
JObject requestParameters = new JObject();
if (maxLimit > 0)
{
requestParameters["limit"] = maxLimit;
}
requestParameters["after"] = true;
if (parameters != null)
{
foreach (var kvp in parameters)
{
requestParameters[kvp.Key] = kvp.Value.ToString();
}
}
List <T> results = new List <T>();
string token = null;
int cursor = -1;
int count = 0;
do
{
if (!string.IsNullOrEmpty(token) && cursor > 0)
{
requestParameters["token"] = token;
requestParameters["cursor"] = cursor;
}
T data = await this.PostAsync <T>(requestUri, AdvancedHttpClient.CreateContentFromObject(requestParameters));
if (data != null)
{
results.Add(data);
count += data.GetItemCount();
if (data.cursor < data.total_page)
{
token = data.token;
cursor = data.cursor;
}
else
{
token = null;
cursor = -1;
}
}
}while (count < maxResults && !string.IsNullOrEmpty(token));
return(results);
}
/// <summary>
/// Ends the poll for the specified broadcaster and poll ID.
/// </summary>
/// <param name="broadcaster">The broadcaster to get the poll for</param>
/// <param name="id">The ID of the poll to get</param>
/// <returns>The poll</returns>
public async Task <PollModel> EndPoll(UserModel broadcaster, string id)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
Validator.ValidateString(id, "id");
JObject jobj = new JObject();
jobj["broadcaster_id"] = broadcaster.id;
jobj["id"] = id;
jobj["status"] = "TERMINATED";
return((await this.PostDataResultAsync <PollModel>("polls", AdvancedHttpClient.CreateContentFromObject(jobj)))?.FirstOrDefault());
}
