/// <summary>
/// Sends a message to the specified broadcaster's channel.
/// </summary>
/// <param name="broadcaster">The broadcaster's channel to send the message to</param>
/// <param name="user">The user to whisper</param>
/// <param name="message">The message to send</param>
/// <returns>An awaitable Task</returns>
public async Task SendWhisperMessage(NewAPI.Users.UserModel broadcaster, NewAPI.Users.UserModel user, string message)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
Validator.ValidateVariable(user, "user");
Validator.ValidateString(message, "message");
await this.Send(string.Format("PRIVMSG #{0} :.w {1} {2}", broadcaster.login, user.login, message));
}
/// <summary>
/// Sends a reply message to the specified broadcaster's channel and message ID.
/// </summary>
/// <param name="broadcaster">The broadcaster's channel to send the message to</param>
/// <param name="message">The message to send</param>
/// <param name="messageID">The message ID to reply to</param>
/// <returns>An awaitable Task</returns>
public async Task SendReplyMessage(NewAPI.Users.UserModel broadcaster, string message, string messageID)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
Validator.ValidateString(message, "message");
Validator.ValidateString(messageID, "messageID");
await this.Send(string.Format("@reply-parent-msg-id={0} PRIVMSG #{1} :{2}", messageID, broadcaster.login, message));
}
public async Task <NewAPI.Users.UserFollowModel> CheckIfFollowsNewAPI(NewAPI.Users.UserModel channel, NewAPI.Users.UserModel userToCheck)
{
IEnumerable <NewAPI.Users.UserFollowModel> follows = await this.RunAsync(this.Connection.NewAPI.Users.GetFollows(from: userToCheck, to: channel, maxResults: 1));
if (follows != null)
{
return(follows.FirstOrDefault());
}
return(null);
}
/// <summary>
/// Connects to the default ChatClient connection.
/// </summary>
/// <returns>An awaitable Task</returns>
public async Task Connect()
{
await base.Connect(ChatClient.CHAT_CONNECTION_URL);
OAuthTokenModel oauthToken = await this.connection.GetOAuthToken();
await this.Send("PASS oauth:" + oauthToken.accessToken);
NewAPI.Users.UserModel user = await this.connection.NewAPI.Users.GetCurrentUser();
await this.Send("NICK " + user.login.ToLower());
}
public async Task <NewAPI.Streams.StreamModel> GetStream(NewAPI.Users.UserModel user)
{
IEnumerable <NewAPI.Streams.StreamModel> results = await this.RunAsync(this.Connection.NewAPI.Streams.GetStreamsByUserIDs(userIDs: new List <string>()
{
user.id
}));
if (results != null)
{
return(results.FirstOrDefault());
}
return(null);
}
public async Task <UserViewModel> AddOrUpdateUser(TwitchNewAPI.Users.UserModel twitchChatUser)
{
if (!string.IsNullOrEmpty(twitchChatUser.id) && !string.IsNullOrEmpty(twitchChatUser.login))
{
UserViewModel user = new UserViewModel(twitchChatUser);
if (this.usersByTwitchID.ContainsKey(twitchChatUser.id))
{
user = this.usersByTwitchID[twitchChatUser.id];
}
await this.AddOrUpdateUser(user);
return(user);
}
return(null);
}
/// <summary>
/// Connects to the default ChatClient connection.
/// </summary>
/// <param name="connectionURL">The URL to connect to</param>
/// <returns>An awaitable Task</returns>
protected async Task Connect(string connectionURL)
{
await base.Connect(connectionURL);
await this.AddCommandsCapability();
await this.AddTagsCapability();
await this.AddMembershipCapability();
OAuthTokenModel oauthToken = await this.connection.GetOAuthToken();
await this.Send("PASS oauth:" + oauthToken.accessToken);
NewAPI.Users.UserModel user = await this.connection.NewAPI.Users.GetCurrentUser();
await this.Send("NICK " + user.login.ToLower());
}
public static async Task <UserViewModel> SearchForUser(string username, StreamingPlatformTypeEnum platform = StreamingPlatformTypeEnum.All)
{
username = username.Replace("@", "");
UserViewModel user = ChannelSession.Services.User.GetUserByUsername(username, platform);
if (user == null)
{
if (platform.HasFlag(StreamingPlatformTypeEnum.Twitch) && ChannelSession.TwitchUserConnection != null)
{
Twitch.Base.Models.NewAPI.Users.UserModel twitchUser = await ChannelSession.TwitchUserConnection.GetNewAPIUserByLogin(username);
if (twitchUser != null)
{
user = new UserViewModel(twitchUser);
}
}
}
return(user);
}
public static async Task RefreshUser()
{
if (ChannelSession.TwitchUserNewAPI != null)
{
TwitchNewAPI.Users.UserModel twitchUserNewAPI = await ChannelSession.TwitchUserConnection.GetNewAPICurrentUser();
if (twitchUserNewAPI != null)
{
ChannelSession.TwitchUserNewAPI = twitchUserNewAPI;
TwitchV5API.Users.UserModel twitchUserV5 = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(ChannelSession.TwitchUserNewAPI.login);
if (twitchUserV5 != null)
{
ChannelSession.TwitchUserV5 = twitchUserV5;
}
}
}
}
public async Task <Result <NewAPI.ChannelPoints.CustomChannelPointRewardModel> > CreateCustomChannelPointRewards(NewAPI.Users.UserModel broadcaster, NewAPI.ChannelPoints.UpdatableCustomChannelPointRewardModel reward)
{
try
{
return(new Result <NewAPI.ChannelPoints.CustomChannelPointRewardModel>(await this.Connection.NewAPI.ChannelPoints.CreateCustomReward(broadcaster, reward)));
}
catch (HttpRestRequestException ex)
{
return(new Result <NewAPI.ChannelPoints.CustomChannelPointRewardModel>(await ex.Response.Content.ReadAsStringAsync()));
}
catch (Exception ex)
{
return(new Result <NewAPI.ChannelPoints.CustomChannelPointRewardModel>(ex.Message));
}
}
public async Task <IEnumerable <NewAPI.Chat.ChatBadgeSetModel> > GetChannelChatBadges(NewAPI.Users.UserModel channel)
{
return(await this.RunAsync(this.Connection.NewAPI.Chat.GetChannelChatBadges(channel)));
}
public async Task <IEnumerable <NewAPI.Bits.BitsCheermoteModel> > GetBitsCheermotes(NewAPI.Users.UserModel channel)
{
return(await this.RunAsync(this.Connection.NewAPI.Bits.GetCheermotes(channel)));
}
public async Task <NewAPI.Clips.ClipCreationModel> CreateClip(NewAPI.Users.UserModel channel, bool delay)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Clips.CreateClip(channel, delay)));
}
public async Task <NewAPI.Ads.AdResponseModel> RunAd(NewAPI.Users.UserModel channel, int length)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Ads.RunAd(channel, length)));
}
public async Task <bool> GetStreamTagsForChannel(NewAPI.Users.UserModel channel, IEnumerable <NewAPI.Tags.TagModel> tags)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Tags.UpdateStreamTags(channel, tags)));
}
/// <summary>
/// Purges a user's messages.
/// </summary>
/// <param name="broadcaster">The broadcaster's channel to use</param>
/// <param name="targetUser">The target user to purge</param>
/// <param name="lengthInSeconds">The length in seconds to time out for</param>
/// <returns>An awaitable Task</returns>
public async Task TimeoutUser(NewAPI.Users.UserModel broadcaster, NewAPI.Users.UserModel targetUser, int lengthInSeconds)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
Validator.ValidateVariable(targetUser, "targetUser");
await this.Send(string.Format("PRIVMSG #{0} :.timeout {1} {2}", broadcaster.login, targetUser.login, lengthInSeconds));
}
public async Task <CreatedStreamMarkerModel> CreateStreamMarker(NewAPI.Users.UserModel channel, string description)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Streams.CreateStreamMarker(channel, description)));
}
public async Task <NewAPI.Polls.PollModel> GetPoll(NewAPI.Users.UserModel broadcaster, string pollID)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Polls.GetPoll(broadcaster, pollID)));
}
public async Task <IEnumerable <NewAPI.Chat.ChatEmoteModel> > GetChannelEmotes(NewAPI.Users.UserModel broadcaster)
{
return(await this.RunAsync(this.Connection.NewAPI.Chat.GetChannelEmotes(broadcaster)));
}
public async Task <IEnumerable <NewAPI.ChannelPoints.CustomChannelPointRewardModel> > GetCustomChannelPointRewards(NewAPI.Users.UserModel broadcaster)
{
return(await this.RunAsync(this.Connection.NewAPI.ChannelPoints.GetCustomRewards(broadcaster)));
}
public async Task <IEnumerable <NewAPI.Users.UserFollowModel> > GetNewAPIFollowers(NewAPI.Users.UserModel channel, int maxResult = 1)
{
return(await this.RunAsync(this.Connection.NewAPI.Users.GetFollows(to: channel, maxResults: maxResult)));
}
/// <summary>
/// Runs a commercial for the specified time length in specified broadcaster's channel.
/// </summary>
/// <param name="broadcaster">The broadcaster's channel</param>
/// <param name="lengthInSeconds">The length of the commercial</param>
/// <returns>An awaitable Task</returns>
public async Task RunCommercial(NewAPI.Users.UserModel broadcaster, int lengthInSeconds)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
await this.Send(string.Format("PRIVMSG #{0} :.commercial {1}", broadcaster.login, lengthInSeconds));
}
/// <summary>
/// Bans the specified user in specified broadcaster's channel.
/// </summary>
/// <param name="broadcaster">The broadcaster's channel</param>
/// <param name="user">The user to ban</param>
/// <returns>An awaitable Task</returns>
public async Task UnbanUser(NewAPI.Users.UserModel broadcaster, NewAPI.Users.UserModel user)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
Validator.ValidateVariable(user, "user");
await this.Send(string.Format("PRIVMSG #{0} :.unban {1}", broadcaster.login, user.login));
}
/// <summary>
/// Clears all messages from chat.
/// </summary>
/// <param name="broadcaster">The broadcaster's channel to use</param>
/// <returns>An awaitable Task</returns>
public async Task ClearChat(NewAPI.Users.UserModel broadcaster)
{
Validator.ValidateVariable(broadcaster, "broadcaster");
await this.Send(string.Format("PRIVMSG #{0} :.clear", broadcaster.login));
}
public async Task <NewAPI.ChannelPoints.CustomChannelPointRewardModel> UpdateCustomChannelPointReward(NewAPI.Users.UserModel broadcaster, Guid id, JObject jobj)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.ChannelPoints.UpdateCustomReward(broadcaster, id, jobj)));
}
public async Task <NewAPI.Channels.ChannelInformationModel> GetChannelInformation(NewAPI.Users.UserModel channel)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Channels.GetChannelInformation(channel)));
}
public async Task <NewAPI.Predictions.PredictionModel> GetPrediction(NewAPI.Users.UserModel broadcaster, string predictionID)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Predictions.GetPrediction(broadcaster, predictionID)));
}
public async Task <bool> UpdateChannelInformation(NewAPI.Users.UserModel channel, string title = null, string gameID = null)
{
return(await AsyncRunner.RunAsync(this.Connection.NewAPI.Channels.UpdateChannelInformation(channel, title, gameID)));
}
public UserDataImportWindowViewModel()
{
this.Columns.Add(new UserDataImportColumnViewModel(UserDataImportColumnViewModel.TwitchIDColumn));
this.Columns.Add(new UserDataImportColumnViewModel(UserDataImportColumnViewModel.TwitchUsernameColumn));
this.Columns.Add(new UserDataImportColumnViewModel(UserDataImportColumnViewModel.MixerUsernameColumn));
this.Columns.Add(new UserDataImportColumnViewModel(UserDataImportColumnViewModel.LiveViewingHoursColumn));
this.Columns.Add(new UserDataImportColumnViewModel(UserDataImportColumnViewModel.LiveViewingMinutesColumn));
this.Columns.Add(new UserDataImportColumnViewModel(UserDataImportColumnViewModel.OfflineViewingHoursColumn));
this.Columns.Add(new UserDataImportColumnViewModel(UserDataImportColumnViewModel.OfflineViewingMinutesColumn));
foreach (CurrencyModel currency in ChannelSession.Settings.Currency.Values)
{
this.Columns.Add(new UserDataImportColumnViewModel(currency.Name));
}
foreach (UserDataImportColumnViewModel column in this.Columns)
{
this.columnDictionary[column.Name] = column;
}
this.UserDataFileBrowseCommand = this.CreateCommand((parameter) =>
{
string filePath = ChannelSession.Services.FileService.ShowOpenFileDialog("Valid Data File Types|*.txt;*.csv;*.xls;*.xlsx");
if (!string.IsNullOrEmpty(filePath))
{
this.UserDataFilePath = filePath;
}
return(Task.FromResult(0));
});
this.ImportButtonCommand = this.CreateCommand(async(parameter) =>
{
try
{
int usersImported = 0;
int failedImports = 0;
if (string.IsNullOrEmpty(this.UserDataFilePath) || !File.Exists(this.UserDataFilePath))
{
await DialogHelper.ShowMessage("A valid data file must be specified");
return;
}
if (!this.Columns[0].ColumnNumber.HasValue && !this.Columns[1].ColumnNumber.HasValue)
{
await DialogHelper.ShowMessage("Your data file must include at least either" + Environment.NewLine + "the Mixer ID or Username columns.");
return;
}
List <UserDataImportColumnViewModel> importingColumns = new List <UserDataImportColumnViewModel>();
foreach (UserDataImportColumnViewModel column in this.Columns.Skip(2))
{
if (column.ColumnNumber.HasValue && column.ColumnNumber <= 0)
{
await DialogHelper.ShowMessage("A number 0 or greater must be specified for" + Environment.NewLine + "each column that you want to include.");
return;
}
importingColumns.Add(column);
}
Dictionary <string, CurrencyModel> nameToCurrencies = new Dictionary <string, CurrencyModel>();
foreach (CurrencyModel currency in ChannelSession.Settings.Currency.Values)
{
nameToCurrencies[currency.Name] = currency;
}
List <List <string> > lines = new List <List <string> >();
string extension = Path.GetExtension(this.UserDataFilePath);
if (extension.Equals(".txt") || extension.Equals(".csv"))
{
string fileContents = await ChannelSession.Services.FileService.ReadFile(this.UserDataFilePath);
if (!string.IsNullOrEmpty(fileContents))
{
foreach (string line in fileContents.Split(new string[] { "\n", Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries))
{
List <string> splits = new List <string>();
foreach (string split in line.Split(new char[] { ' ', '\t', ',', ';' }))
{
splits.Add(split);
}
lines.Add(splits);
}
}
else
{
await DialogHelper.ShowMessage("We were unable to read data from the file. Please make sure it is not already opened in another program.");
}
}
else if (extension.Equals(".xls") || extension.Equals(".xlsx"))
{
using (var stream = File.Open(this.UserDataFilePath, FileMode.Open, FileAccess.Read))
{
using (var reader = ExcelReaderFactory.CreateReader(stream))
{
var result = reader.AsDataSet();
if (result.Tables.Count > 0)
{
for (int i = 0; i < result.Tables[0].Rows.Count; i++)
{
List <string> values = new List <string>();
for (int j = 0; j < result.Tables[0].Rows[i].ItemArray.Length; j++)
{
values.Add(result.Tables[0].Rows[i].ItemArray[j].ToString());
}
lines.Add(values);
}
}
}
}
}
if (lines.Count > 0)
{
foreach (List <string> line in lines)
{
try
{
long twitchID = 0;
if (this.columnDictionary[UserDataImportColumnViewModel.TwitchIDColumn].ArrayNumber >= 0)
{
long.TryParse(line[this.columnDictionary[UserDataImportColumnViewModel.TwitchIDColumn].ArrayNumber], out twitchID);
}
string twitchUsername = null;
if (this.columnDictionary[UserDataImportColumnViewModel.TwitchUsernameColumn].ArrayNumber >= 0)
{
twitchUsername = line[this.columnDictionary[UserDataImportColumnViewModel.TwitchUsernameColumn].ArrayNumber];
}
string mixerUsername = null;
if (this.columnDictionary[UserDataImportColumnViewModel.MixerUsernameColumn].ArrayNumber >= 0)
{
mixerUsername = line[this.columnDictionary[UserDataImportColumnViewModel.MixerUsernameColumn].ArrayNumber];
}
bool newUser = true;
UserDataModel user = null;
if (twitchID > 0)
{
user = ChannelSession.Settings.GetUserDataByTwitchID(twitchID.ToString());
if (user != null)
{
newUser = false;
}
else
{
Twitch.Base.Models.NewAPI.Users.UserModel twitchUser = await ChannelSession.TwitchUserConnection.GetNewAPIUserByID(twitchID.ToString());
if (twitchUser != null)
{
UserViewModel userViewModel = new UserViewModel(twitchUser);
user = userViewModel.Data;
}
}
}
else if (!string.IsNullOrEmpty(twitchUsername))
{
Twitch.Base.Models.NewAPI.Users.UserModel twitchUser = await ChannelSession.TwitchUserConnection.GetNewAPIUserByLogin(twitchUsername);
if (twitchUser != null)
{
user = ChannelSession.Settings.GetUserDataByTwitchID(twitchUser.id);
if (user != null)
{
newUser = false;
}
else
{
UserViewModel userViewModel = new UserViewModel(twitchUser);
user = userViewModel.Data;
}
}
}
else if (!string.IsNullOrEmpty(mixerUsername))
{
#pragma warning disable CS0612 // Type or member is obsolete
UserDataModel mixerUserData = ChannelSession.Settings.GetUserDataByUsername(StreamingPlatformTypeEnum.Mixer, mixerUsername);
#pragma warning restore CS0612 // Type or member is obsolete
if (mixerUserData != null)
{
newUser = false;
}
else
{
user = new UserDataModel()
{
MixerID = uint.MaxValue,
MixerUsername = mixerUsername
};
}
}
if (user != null)
{
if (newUser)
{
ChannelSession.Settings.AddUserData(user);
}
int iValue = 0;
if (this.GetIntValueFromLineColumn(UserDataImportColumnViewModel.LiveViewingHoursColumn, line, out iValue))
{
user.ViewingHoursPart = iValue;
}
if (this.GetIntValueFromLineColumn(UserDataImportColumnViewModel.LiveViewingMinutesColumn, line, out iValue))
{
user.ViewingMinutesPart = iValue;
}
if (this.GetIntValueFromLineColumn(UserDataImportColumnViewModel.OfflineViewingHoursColumn, line, out iValue))
{
user.OfflineViewingMinutes = iValue;
}
if (this.GetIntValueFromLineColumn(UserDataImportColumnViewModel.OfflineViewingMinutesColumn, line, out iValue))
{
user.OfflineViewingMinutes = iValue;
}
foreach (var kvp in nameToCurrencies)
{
if (this.GetIntValueFromLineColumn(kvp.Key, line, out iValue))
{
kvp.Value.SetAmount(user, iValue);
}
}
ChannelSession.Settings.UserData.ManualValueChanged(user.ID);
usersImported++;
this.ImportButtonText = string.Format("{0} {1}", usersImported, MixItUp.Base.Resources.Imported);
}
else
{
failedImports++;
}
}
catch (Exception ex)
{
Logger.Log(LogLevel.Error, "User Data Import Failure - " + line);
Logger.Log(ex);
failedImports++;
}
}
}
await ChannelSession.SaveSettings();
if (failedImports > 0)
{
await DialogHelper.ShowMessage($"{usersImported} users were imported successfully, but {failedImports} users were not able to be imported. This could be due to invalid data or failure to find their information on the platform. Please contact support for further help with this if needed");
}
else
{
await DialogHelper.ShowMessage($"{usersImported} users were imported successfully");
}
}
catch (Exception ex)
{
Logger.Log(ex);
await DialogHelper.ShowMessage("We were unable to read data from the file. Please make sure it is not already opened in another program. If this continues, please reach out to support.");
}
this.ImportButtonText = MixItUp.Base.Resources.ImportData;
});
}
public async Task <IEnumerable <NewAPI.Tags.TagModel> > GetStreamTagsForChannel(NewAPI.Users.UserModel channel)
{
return(await this.RunAsync(this.Connection.NewAPI.Tags.GetStreamTagsForBroadcaster(channel)));
}
