public async Task SavePackagedBackup(SettingsV2Model settings, string filePath) { await this.Save(ChannelSession.Settings); try { if (Directory.Exists(Path.GetDirectoryName(filePath))) { if (File.Exists(filePath)) { File.Delete(filePath); } using (ZipArchive zipFile = ZipFile.Open(filePath, ZipArchiveMode.Create)) { zipFile.CreateEntryFromFile(settings.SettingsFilePath, Path.GetFileName(settings.SettingsFilePath)); if (settings.IsStreamer) { zipFile.CreateEntryFromFile(settings.DatabaseFilePath, Path.GetFileName(settings.DatabaseFilePath)); } } } else { Logger.Log(LogLevel.Error, $"Directory does not exist for saving packaged backup: {filePath}"); } } catch (Exception ex) { Logger.Log(ex); } }
public static async Task Version44Upgrade(string filePath) { SettingsV2Model settings = await FileSerializerHelper.DeserializeFromFile <SettingsV2Model>(filePath, ignoreErrors : true); await settings.Initialize(); #pragma warning disable CS0612 // Type or member is obsolete if (settings.ChatShowUserJoinLeave) { settings.AlertUserJoinLeaveColor = settings.ChatUserJoinLeaveColorScheme; } if (settings.ChatShowEventAlerts) { settings.AlertBitsCheeredColor = settings.ChatEventAlertsColorScheme; settings.AlertChannelPointsColor = settings.ChatEventAlertsColorScheme; settings.AlertFollowColor = settings.ChatEventAlertsColorScheme; settings.AlertGiftedSubColor = settings.ChatEventAlertsColorScheme; settings.AlertHostColor = settings.ChatEventAlertsColorScheme; settings.AlertMassGiftedSubColor = settings.ChatEventAlertsColorScheme; settings.AlertModerationColor = settings.ChatEventAlertsColorScheme; settings.AlertRaidColor = settings.ChatEventAlertsColorScheme; settings.AlertSubColor = settings.ChatEventAlertsColorScheme; } #pragma warning restore CS0612 // Type or member is obsolete await ChannelSession.Services.Settings.Save(settings); }
public async Task SaveLocalBackup(SettingsV2Model settings) { Logger.Log(LogLevel.Debug, "Settings local backup save operation started"); await semaphore.WaitAndRelease(async() => { await FileSerializerHelper.SerializeToFile(settings.SettingsLocalBackupFilePath, settings); }); Logger.Log(LogLevel.Debug, "Settings local backup save operation finished"); }
public static async Task Version41Upgrade(string filePath) { SettingsV2Model settings = await FileSerializerHelper.DeserializeFromFile <SettingsV2Model>(filePath, ignoreErrors : true); // Check if the old CurrencyAmounts and InventoryAmounts tables exist bool tablesExist = false; await ChannelSession.Services.Database.Read(settings.DatabaseFilePath, "SELECT * FROM CurrencyAmounts LIMIT 1", (Dictionary <string, object> data) => { if (data.Count > 0) { tablesExist = true; } }); if (tablesExist) { await settings.Initialize(); await ChannelSession.Services.Database.Read(settings.DatabaseFilePath, "SELECT * FROM CurrencyAmounts", (Dictionary <string, object> data) => { Guid currencyID = Guid.Parse((string)data["CurrencyID"]); Guid userID = Guid.Parse((string)data["UserID"]); int amount = Convert.ToInt32(data["Amount"]); if (amount > 0 && settings.UserData.ContainsKey(userID)) { settings.UserData[userID].CurrencyAmounts[currencyID] = amount; settings.UserData.ManualValueChanged(userID); } }); await ChannelSession.Services.Database.Read(settings.DatabaseFilePath, "SELECT * FROM InventoryAmounts", (Dictionary <string, object> data) => { Guid inventoryID = Guid.Parse((string)data["InventoryID"]); Guid userID = Guid.Parse((string)data["UserID"]); Guid itemID = Guid.Parse((string)data["ItemID"]); int amount = Convert.ToInt32(data["Amount"]); if (amount > 0 && settings.UserData.ContainsKey(userID)) { if (!settings.UserData[userID].InventoryAmounts.ContainsKey(inventoryID)) { settings.UserData[userID].InventoryAmounts[inventoryID] = new Dictionary <Guid, int>(); } settings.UserData[userID].InventoryAmounts[inventoryID][itemID] = amount; settings.UserData.ManualValueChanged(userID); } }); await ChannelSession.Services.Settings.Save(settings); } }
#pragma warning disable CS0612 // Type or member is obsolete public async Task Save(SettingsV2Model settings) { Logger.Log(LogLevel.Debug, "Settings save operation started"); await semaphore.WaitAndRelease(async() => { settings.CopyLatestValues(); await FileSerializerHelper.SerializeToFile(settings.SettingsFilePath, settings); await settings.SaveDatabaseData(); }); Logger.Log(LogLevel.Debug, "Settings save operation finished"); }
public async Task PerformAutomaticBackupIfApplicable(SettingsV2Model settings) { if (settings.SettingsBackupRate != SettingsBackupRateEnum.None) { Logger.Log(LogLevel.Debug, "Checking whether to perform automatic backup"); DateTimeOffset newResetDate = settings.SettingsLastBackup; if (settings.SettingsBackupRate == SettingsBackupRateEnum.Daily) { newResetDate = newResetDate.AddDays(1); } else if (settings.SettingsBackupRate == SettingsBackupRateEnum.Weekly) { newResetDate = newResetDate.AddDays(7); } else if (settings.SettingsBackupRate == SettingsBackupRateEnum.Monthly) { newResetDate = newResetDate.AddMonths(1); } if (newResetDate < DateTimeOffset.Now) { string backupPath = Path.Combine(SettingsV2Model.SettingsDirectoryName, SettingsV2Model.DefaultAutomaticBackupSettingsDirectoryName); if (!string.IsNullOrEmpty(settings.SettingsBackupLocation)) { backupPath = settings.SettingsBackupLocation; } if (!Directory.Exists(backupPath)) { try { Directory.CreateDirectory(backupPath); } catch (Exception ex) { Logger.Log(LogLevel.Error, "Failed to create automatic backup directory"); Logger.Log(ex); return; } } string filePath = Path.Combine(backupPath, settings.MixerChannelID + "-Backup-" + DateTimeOffset.Now.ToString("MM-dd-yyyy") + "." + SettingsV2Model.SettingsBackupFileExtension); await this.SavePackagedBackup(settings, filePath); settings.SettingsLastBackup = DateTimeOffset.Now; } } }
private async Task <bool> ExistingSettingLogin(SettingsV2Model setting) { Result result = await ChannelSession.ConnectUser(setting); if (result.Success) { if (await ChannelSession.InitializeSession()) { return(true); } } else { await DialogHelper.ShowMessage(result.Message); } return(false); }
private async void StreamerLoginButton_Click(object sender, RoutedEventArgs e) { await this.RunAsyncOperation(async() => { if (this.ExistingStreamerComboBox.Visibility == Visibility.Visible) { if (this.ExistingStreamerComboBox.SelectedIndex >= 0) { SettingsV2Model setting = (SettingsV2Model)this.ExistingStreamerComboBox.SelectedItem; if (setting.ID == Guid.Empty) { await this.NewStreamerLogin(); } else { if (await this.ExistingSettingLogin(setting)) { LoadingWindowBase newWindow = null; if (ChannelSession.Settings.ReRunWizard) { newWindow = new NewUserWizardWindow(); } else { newWindow = new MainWindow(); } ShowMainWindow(newWindow); this.Hide(); this.Close(); return; } } } else { await DialogHelper.ShowMessage(MixItUp.Base.Resources.LoginErrorNoStreamerAccount); } } else { await this.NewStreamerLogin(); } }); }
public static async Task <SettingsV2Model> UpgradeSettingsToLatest(string filePath) { int currentVersion = await GetSettingsVersion(filePath); if (currentVersion < 0) { // Settings file is invalid, we can't use this return(null); } else if (currentVersion > SettingsV2Model.LatestVersion) { // Future build, like a preview build, we can't load this return(null); } else if (currentVersion < SettingsV2Model.LatestVersion) { // Perform upgrade of settings if (currentVersion < 41) { await SettingsV2Upgrader.Version41Upgrade(filePath); } if (currentVersion < 42) { await SettingsV2Upgrader.Version42Upgrade(filePath); } if (currentVersion < 43) { await SettingsV2Upgrader.Version43Upgrade(filePath); } if (currentVersion < 44) { await SettingsV2Upgrader.Version44Upgrade(filePath); } } SettingsV2Model settings = await FileSerializerHelper.DeserializeFromFile <SettingsV2Model>(filePath, ignoreErrors : true); settings.Version = SettingsV2Model.LatestVersion; return(settings); }
protected override async Task OnLoaded() { GlobalEvents.OnShowMessageBox += GlobalEvents_OnShowMessageBox; this.Title += " - v" + Assembly.GetEntryAssembly().GetName().Version.ToString(); this.ExistingStreamerComboBox.ItemsSource = streamerSettings; await this.CheckForUpdates(); foreach (SettingsV2Model setting in (await ChannelSession.Services.Settings.GetAllSettings()).OrderBy(s => s.Name)) { if (setting.IsStreamer) { this.streamerSettings.Add(setting); } } if (this.streamerSettings.Count > 0) { this.ExistingStreamerComboBox.Visibility = Visibility.Visible; this.streamerSettings.Add(new SettingsV2Model() { ID = Guid.Empty, Name = MixItUp.Base.Resources.NewStreamer }); if (this.streamerSettings.Count() == 2) { this.ExistingStreamerComboBox.SelectedIndex = 0; } } if (ChannelSession.AppSettings.AutoLogInID != Guid.Empty) { var allSettings = this.streamerSettings.ToList(); SettingsV2Model autoLogInSettings = allSettings.FirstOrDefault(s => s.ID == ChannelSession.AppSettings.AutoLogInID); if (autoLogInSettings != null) { await Task.Delay(5000); if (!updateFound) { if (await this.ExistingSettingLogin(autoLogInSettings)) { LoadingWindowBase newWindow = null; if (ChannelSession.Settings.ReRunWizard) { newWindow = new NewUserWizardWindow(); } else { newWindow = new MainWindow(); } ShowMainWindow(newWindow); this.Hide(); this.Close(); return; } } } } await base.OnLoaded(); }
private static IEnumerable <CommandBase> GetAllCommands(SettingsV2Model settings) { List <CommandBase> commands = new List <CommandBase>(); commands.AddRange(settings.ChatCommands); commands.AddRange(settings.EventCommands); commands.AddRange(settings.TimerCommands); commands.AddRange(settings.ActionGroupCommands); commands.AddRange(settings.GameCommands); commands.AddRange(settings.TwitchChannelPointsCommands); commands.AddRange(settings.CustomCommands.Values); foreach (UserDataModel userData in settings.UserData.Values) { commands.AddRange(userData.CustomCommands); if (userData.EntranceCommand != null) { commands.Add(userData.EntranceCommand); } } foreach (GameCommandBase gameCommand in settings.GameCommands) { commands.AddRange(gameCommand.GetAllInnerCommands()); } foreach (OverlayWidgetModel widget in settings.OverlayWidgets) { if (widget.Item is OverlayStreamBossItemModel) { OverlayStreamBossItemModel item = ((OverlayStreamBossItemModel)widget.Item); if (item.NewStreamBossCommand != null) { commands.Add(item.NewStreamBossCommand); } } else if (widget.Item is OverlayProgressBarItemModel) { OverlayProgressBarItemModel item = ((OverlayProgressBarItemModel)widget.Item); if (item.GoalReachedCommand != null) { commands.Add(item.GoalReachedCommand); } } else if (widget.Item is OverlayTimerItemModel) { OverlayTimerItemModel item = ((OverlayTimerItemModel)widget.Item); if (item.TimerCompleteCommand != null) { commands.Add(item.TimerCompleteCommand); } } } commands.Add(settings.GameQueueUserJoinedCommand); commands.Add(settings.GameQueueUserSelectedCommand); commands.Add(settings.GiveawayStartedReminderCommand); commands.Add(settings.GiveawayUserJoinedCommand); commands.Add(settings.GiveawayWinnerSelectedCommand); commands.Add(settings.ModerationStrike1Command); commands.Add(settings.ModerationStrike2Command); commands.Add(settings.ModerationStrike3Command); return(commands.Where(c => c != null)); }
public async Task <IEnumerable <SettingsV2Model> > GetAllSettings() { bool backupSettingsLoaded = false; bool settingsLoadFailure = false; List <SettingsV2Model> allSettings = new List <SettingsV2Model>(); foreach (string filePath in Directory.GetFiles(SettingsV2Model.SettingsDirectoryName)) { if (filePath.EndsWith(SettingsV2Model.SettingsFileExtension)) { SettingsV2Model setting = null; try { setting = await this.LoadSettings(filePath); if (setting != null) { allSettings.Add(setting); } } catch (Exception ex) { Logger.Log(ex); } if (setting == null) { string localBackupFilePath = string.Format($"{filePath}.{SettingsV2Model.SettingsLocalBackupFileExtension}"); if (File.Exists(localBackupFilePath)) { try { setting = await this.LoadSettings(localBackupFilePath); if (setting != null) { allSettings.Add(setting); backupSettingsLoaded = true; } } catch (Exception ex) { Logger.Log(ex); } } } if (setting == null) { settingsLoadFailure = true; } } } if (!string.IsNullOrEmpty(ChannelSession.AppSettings.BackupSettingsFilePath) && ChannelSession.AppSettings.BackupSettingsToReplace != Guid.Empty) { Logger.Log(LogLevel.Debug, "Restored settings file detected, starting restore process"); SettingsV2Model settings = allSettings.FirstOrDefault(s => s.ID.Equals(ChannelSession.AppSettings.BackupSettingsToReplace)); if (settings != null) { File.Delete(settings.SettingsFilePath); File.Delete(settings.DatabaseFilePath); using (ZipArchive zipFile = ZipFile.Open(ChannelSession.AppSettings.BackupSettingsFilePath, ZipArchiveMode.Read)) { zipFile.ExtractToDirectory(SettingsV2Model.SettingsDirectoryName); } ChannelSession.AppSettings.BackupSettingsFilePath = null; ChannelSession.AppSettings.BackupSettingsToReplace = Guid.Empty; return(await this.GetAllSettings()); } } else if (ChannelSession.AppSettings.SettingsToDelete != Guid.Empty) { Logger.Log(LogLevel.Debug, "Settings deletion detected, starting deletion process"); SettingsV2Model settings = allSettings.FirstOrDefault(s => s.ID.Equals(ChannelSession.AppSettings.SettingsToDelete)); if (settings != null) { File.Delete(settings.SettingsFilePath); File.Delete(settings.DatabaseFilePath); ChannelSession.AppSettings.SettingsToDelete = Guid.Empty; return(await this.GetAllSettings()); } } if (backupSettingsLoaded) { await DialogHelper.ShowMessage("One or more of the settings file could not be loaded due to file corruption and the most recent local backup was loaded instead."); } if (settingsLoadFailure) { await DialogHelper.ShowMessage("One or more settings files were unable to be loaded. Please visit the Mix It Up discord for assistance on this issue."); } return(allSettings); }
public async Task Initialize(SettingsV2Model settings) { await settings.Initialize(); }
public static async Task Version43Upgrade(string filePath) { SettingsV2Model settings = await FileSerializerHelper.DeserializeFromFile <SettingsV2Model>(filePath, ignoreErrors : true); await settings.Initialize(); if (settings.IsStreamer) { List <EventCommand> eventCommandsToAdd = new List <EventCommand>(); List <EventCommand> eventCommandsToRemove = new List <EventCommand>(); foreach (EventCommand command in settings.EventCommands) { EventCommand newCommand = null; switch (command.EventCommandType) { #pragma warning disable CS0612 // Type or member is obsolete case EventTypeEnum.MixerChannelEmbersUsed: newCommand = new EventCommand(EventTypeEnum.TwitchChannelBitsCheered); break; case EventTypeEnum.MixerChannelFollowed: newCommand = new EventCommand(EventTypeEnum.TwitchChannelFollowed); break; case EventTypeEnum.MixerChannelHosted: newCommand = new EventCommand(EventTypeEnum.TwitchChannelRaided); break; case EventTypeEnum.MixerChannelResubscribed: newCommand = new EventCommand(EventTypeEnum.TwitchChannelResubscribed); break; case EventTypeEnum.MixerChannelStreamStart: newCommand = new EventCommand(EventTypeEnum.TwitchChannelStreamStart); break; case EventTypeEnum.MixerChannelStreamStop: newCommand = new EventCommand(EventTypeEnum.TwitchChannelStreamStop); break; case EventTypeEnum.MixerChannelSubscribed: newCommand = new EventCommand(EventTypeEnum.TwitchChannelSubscribed); break; case EventTypeEnum.MixerChannelSubscriptionGifted: newCommand = new EventCommand(EventTypeEnum.TwitchChannelSubscriptionGifted); break; case EventTypeEnum.MixerChannelUnfollowed: newCommand = new EventCommand(EventTypeEnum.TwitchChannelUnfollowed); break; #pragma warning restore CS0612 // Type or member is obsolete } if (newCommand != null) { eventCommandsToAdd.Add(newCommand); eventCommandsToRemove.Add(command); newCommand.Actions.AddRange(command.Actions); newCommand.Unlocked = command.Unlocked; newCommand.IsEnabled = command.IsEnabled; } } foreach (EventCommand command in eventCommandsToRemove) { settings.EventCommands.Remove(command); } foreach (EventCommand command in eventCommandsToAdd) { settings.EventCommands.Add(command); } settings.StreamElementsOAuthToken = null; settings.StreamJarOAuthToken = null; settings.StreamlabsOAuthToken = null; settings.TipeeeStreamOAuthToken = null; settings.TreatStreamOAuthToken = null; } await ChannelSession.Services.Settings.Save(settings); }
public static async Task Version42Upgrade(string filePath) { SettingsV2Model settings = await FileSerializerHelper.DeserializeFromFile <SettingsV2Model>(filePath, ignoreErrors : true); if (settings.IsStreamer) { List <UserQuoteModel> quotes = new List <UserQuoteModel>(); await ChannelSession.Services.Database.Read(settings.DatabaseFilePath, "SELECT * FROM Quotes", (Dictionary <string, object> data) => { string json = (string)data["Data"]; json = json.Replace("MixItUp.Base.ViewModel.User.UserQuoteViewModel", "MixItUp.Base.Model.User.UserQuoteModel"); quotes.Add(JSONSerializerHelper.DeserializeFromString <UserQuoteModel>(json)); }); await ChannelSession.Services.Database.BulkWrite(settings.DatabaseFilePath, "REPLACE INTO Quotes(ID, Data) VALUES(@ID, @Data)", quotes.Select(q => new Dictionary <string, object>() { { "@ID", q.ID.ToString() }, { "@Data", JSONSerializerHelper.SerializeToString(q) } })); } await settings.Initialize(); #pragma warning disable CS0612 // Type or member is obsolete if (settings.DiagnosticLogging) { ChannelSession.AppSettings.DiagnosticLogging = true; } #pragma warning restore CS0612 // Type or member is obsolete #pragma warning disable CS0612 // Type or member is obsolete foreach (UserCurrencyModel oldCurrency in settings.Currencies.Values) { CurrencyModel newCurrency = new CurrencyModel(); newCurrency.ID = oldCurrency.ID; newCurrency.Name = oldCurrency.Name; newCurrency.AcquireAmount = oldCurrency.AcquireAmount; newCurrency.AcquireInterval = oldCurrency.AcquireInterval; newCurrency.MinimumActiveRate = oldCurrency.MinimumActiveRate; newCurrency.OfflineAcquireAmount = oldCurrency.OfflineAcquireAmount; newCurrency.OfflineAcquireInterval = oldCurrency.OfflineAcquireInterval; newCurrency.MaxAmount = oldCurrency.MaxAmount; newCurrency.SpecialIdentifier = oldCurrency.SpecialIdentifier; newCurrency.SubscriberBonus = oldCurrency.SubscriberBonus; newCurrency.ModeratorBonus = oldCurrency.ModeratorBonus; newCurrency.OnFollowBonus = oldCurrency.OnFollowBonus; newCurrency.OnHostBonus = oldCurrency.OnHostBonus; newCurrency.OnSubscribeBonus = oldCurrency.OnSubscribeBonus; newCurrency.ResetInterval = (Model.Currency.CurrencyResetRateEnum)((int)oldCurrency.ResetInterval); newCurrency.ResetStartCadence = oldCurrency.ResetStartCadence; newCurrency.LastReset = oldCurrency.LastReset; newCurrency.IsPrimary = oldCurrency.IsPrimary; if (oldCurrency.RankChangedCommand != null) { settings.SetCustomCommand(oldCurrency.RankChangedCommand); newCurrency.RankChangedCommandID = oldCurrency.RankChangedCommand.ID; } foreach (UserRankViewModel rank in oldCurrency.Ranks) { newCurrency.Ranks.Add(new RankModel(rank.Name, rank.MinimumPoints)); } settings.Currency[newCurrency.ID] = newCurrency; } foreach (UserInventoryModel oldInventory in settings.Inventories.Values) { InventoryModel newInventory = new InventoryModel(); newInventory.ID = oldInventory.ID; newInventory.Name = oldInventory.Name; newInventory.DefaultMaxAmount = oldInventory.DefaultMaxAmount; newInventory.SpecialIdentifier = oldInventory.SpecialIdentifier; newInventory.ShopEnabled = oldInventory.ShopEnabled; newInventory.ShopCommand = oldInventory.ShopCommand; newInventory.ShopCurrencyID = oldInventory.ShopCurrencyID; newInventory.TradeEnabled = oldInventory.TradeEnabled; newInventory.TradeCommand = oldInventory.TradeCommand; if (oldInventory.ItemsBoughtCommand != null) { settings.SetCustomCommand(oldInventory.ItemsBoughtCommand); newInventory.ItemsBoughtCommandID = oldInventory.ItemsBoughtCommand.ID; } else { CustomCommand buyCommand = new CustomCommand(InventoryWindowViewModel.ItemsBoughtCommandName); buyCommand.Actions.Add(new ChatAction("You bought $itemtotal $itemname for $itemcost $currencyname", sendAsStreamer: false)); settings.SetCustomCommand(buyCommand); newInventory.ItemsBoughtCommandID = buyCommand.ID; } if (oldInventory.ItemsSoldCommand != null) { settings.SetCustomCommand(oldInventory.ItemsSoldCommand); newInventory.ItemsSoldCommandID = oldInventory.ItemsSoldCommand.ID; } else { CustomCommand sellCommand = new CustomCommand(InventoryWindowViewModel.ItemsSoldCommandName); sellCommand.Actions.Add(new ChatAction("You sold $itemtotal $itemname for $itemcost $currencyname", sendAsStreamer: false)); settings.SetCustomCommand(sellCommand); newInventory.ItemsSoldCommandID = sellCommand.ID; } if (oldInventory.ItemsTradedCommand != null) { settings.SetCustomCommand(oldInventory.ItemsTradedCommand); newInventory.ItemsTradedCommandID = oldInventory.ItemsTradedCommand.ID; } else { CustomCommand tradeCommand = new CustomCommand(InventoryWindowViewModel.ItemsTradedCommandName); tradeCommand.Actions.Add(new ChatAction("@$username traded $itemtotal $itemname to @$targetusername for $targetitemtotal $targetitemname", sendAsStreamer: false)); settings.SetCustomCommand(tradeCommand); newInventory.ItemsTradedCommandID = tradeCommand.ID; } foreach (UserInventoryItemModel oldItem in oldInventory.Items.Values.ToList()) { InventoryItemModel newItem = new InventoryItemModel(oldItem.Name, oldItem.MaxAmount, oldItem.BuyAmount, oldItem.SellAmount); newItem.ID = oldItem.ID; newInventory.Items[newItem.ID] = newItem; } settings.Inventory[newInventory.ID] = newInventory; } #pragma warning restore CS0612 // Type or member is obsolete if (settings.GiveawayRequirements != null && settings.GiveawayRequirements.Inventory != null && settings.Inventory.ContainsKey(settings.GiveawayRequirements.Inventory.InventoryID)) { InventoryModel inventory = settings.Inventory[settings.GiveawayRequirements.Inventory.InventoryID]; #pragma warning disable CS0612 // Type or member is obsolete if (inventory != null && !string.IsNullOrEmpty(settings.GiveawayRequirements.Inventory.ItemName)) { InventoryItemModel item = inventory.GetItem(settings.GiveawayRequirements.Inventory.ItemName); if (item != null) { settings.GiveawayRequirements.Inventory.ItemID = item.ID; } settings.GiveawayRequirements.Inventory.ItemName = null; } #pragma warning restore CS0612 // Type or member is obsolete } foreach (CommandBase command in SettingsV2Upgrader.GetAllCommands(settings)) { if (command is PermissionsCommandBase) { PermissionsCommandBase pCommand = (PermissionsCommandBase)command; if (pCommand.Requirements != null && pCommand.Requirements.Inventory != null && settings.Inventory.ContainsKey(pCommand.Requirements.Inventory.InventoryID)) { InventoryModel inventory = settings.Inventory[pCommand.Requirements.Inventory.InventoryID]; #pragma warning disable CS0612 // Type or member is obsolete if (inventory != null && !string.IsNullOrEmpty(pCommand.Requirements.Inventory.ItemName)) { InventoryItemModel item = inventory.GetItem(pCommand.Requirements.Inventory.ItemName); if (item != null) { pCommand.Requirements.Inventory.ItemID = item.ID; } pCommand.Requirements.Inventory.ItemName = null; } #pragma warning restore CS0612 // Type or member is obsolete } } } List <UserDataModel> usersToRemove = new List <UserDataModel>(); foreach (UserDataModel user in settings.UserData.Values.ToList()) { if (user.MixerID <= 0) { usersToRemove.Add(user); } } foreach (UserDataModel user in usersToRemove) { settings.UserData.Remove(user.ID); } await ChannelSession.Services.Settings.Save(settings); }
#pragma warning disable CS0612 // Type or member is obsolete public static async Task UpgradeV2ToV3(string filePath) { SettingsV2Model oldSettings = await FileSerializerHelper.DeserializeFromFile <SettingsV2Model>(filePath, ignoreErrors : true); await oldSettings.Initialize(); if (oldSettings.IsStreamer) { string settingsText = await ChannelSession.Services.FileService.ReadFile(filePath); settingsText = settingsText.Replace("MixItUp.Base.Model.Settings.SettingsV2Model, MixItUp.Base", "MixItUp.Base.Model.Settings.SettingsV3Model, MixItUp.Base"); settingsText = settingsText.Replace("MixItUp.Base.ViewModel.User.UserRoleEnum", "MixItUp.Base.Model.User.UserRoleEnum"); SettingsV3Model newSettings = JSONSerializerHelper.DeserializeFromString <SettingsV3Model>(settingsText, ignoreErrors: true); await newSettings.Initialize(); newSettings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].UserOAuthToken = oldSettings.TwitchUserOAuthToken; newSettings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].UserID = oldSettings.TwitchUserID; newSettings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].ChannelID = oldSettings.TwitchChannelID; newSettings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotID = (oldSettings.TwitchBotOAuthToken != null) ? string.Empty : null; newSettings.StreamingPlatformAuthentications[StreamingPlatformTypeEnum.Twitch].BotOAuthToken = oldSettings.TwitchBotOAuthToken; newSettings.PatreonTierSubscriberEquivalent = oldSettings.PatreonTierMixerSubscriberEquivalent; foreach (var kvp in oldSettings.CooldownGroups) { newSettings.CooldownGroupAmounts[kvp.Key] = kvp.Value; } foreach (var kvp in oldSettings.CommandGroups) { newSettings.CommandGroups[kvp.Key] = new CommandGroupSettingsModel(kvp.Value); } foreach (ChatCommand command in oldSettings.ChatCommands) { newSettings.SetCommand(new ChatCommandModel(command)); } foreach (EventCommand command in oldSettings.EventCommands) { newSettings.SetCommand(new EventCommandModel(command)); } foreach (TimerCommand command in oldSettings.TimerCommands) { newSettings.SetCommand(new TimerCommandModel(command)); } foreach (ActionGroupCommand command in oldSettings.ActionGroupCommands) { newSettings.SetCommand(new ActionGroupCommandModel(command)); } foreach (TwitchChannelPointsCommand command in oldSettings.TwitchChannelPointsCommands) { newSettings.SetCommand(new TwitchChannelPointsCommandModel(command)); } foreach (CustomCommand command in oldSettings.CustomCommands.Values) { newSettings.SetCommand(new CustomCommandModel(command)); } foreach (GameCommandBase command in oldSettings.GameCommands) { if (command.GetType() == typeof(BeachBallGameCommand)) { newSettings.SetCommand(new HotPotatoGameCommandModel((BeachBallGameCommand)command)); } else if (command.GetType() == typeof(BetGameCommand)) { newSettings.SetCommand(new BetGameCommandModel((BetGameCommand)command)); } else if (command.GetType() == typeof(BidGameCommand)) { newSettings.SetCommand(new BidGameCommandModel((BidGameCommand)command)); } else if (command.GetType() == typeof(CoinPusherGameCommand)) { newSettings.SetCommand(new CoinPusherGameCommandModel((CoinPusherGameCommand)command)); } else if (command.GetType() == typeof(DuelGameCommand)) { newSettings.SetCommand(new DuelGameCommandModel((DuelGameCommand)command)); } else if (command.GetType() == typeof(HangmanGameCommand)) { newSettings.SetCommand(new HangmanGameCommandModel((HangmanGameCommand)command)); } else if (command.GetType() == typeof(HeistGameCommand)) { newSettings.SetCommand(new HeistGameCommandModel((HeistGameCommand)command)); } else if (command.GetType() == typeof(HitmanGameCommand)) { newSettings.SetCommand(new HitmanGameCommandModel((HitmanGameCommand)command)); } else if (command.GetType() == typeof(HotPotatoGameCommand)) { newSettings.SetCommand(new HotPotatoGameCommandModel((HotPotatoGameCommand)command)); } else if (command.GetType() == typeof(LockBoxGameCommand)) { newSettings.SetCommand(new LockBoxGameCommandModel((LockBoxGameCommand)command)); } else if (command.GetType() == typeof(PickpocketGameCommand)) { newSettings.SetCommand(new StealGameCommandModel((PickpocketGameCommand)command)); } else if (command.GetType() == typeof(RouletteGameCommand)) { newSettings.SetCommand(new RouletteGameCommandModel((RouletteGameCommand)command)); } else if (command.GetType() == typeof(RussianRouletteGameCommand)) { newSettings.SetCommand(new RussianRouletteGameCommandModel((RussianRouletteGameCommand)command)); } else if (command.GetType() == typeof(SlotMachineGameCommand)) { newSettings.SetCommand(new SlotMachineGameCommandModel((SlotMachineGameCommand)command)); } else if (command.GetType() == typeof(SpinGameCommand)) { newSettings.SetCommand(new SpinGameCommandModel((SpinGameCommand)command)); } else if (command.GetType() == typeof(StealGameCommand)) { newSettings.SetCommand(new StealGameCommandModel((StealGameCommand)command)); } else if (command.GetType() == typeof(TreasureDefenseGameCommand)) { newSettings.SetCommand(new TreasureDefenseGameCommandModel((TreasureDefenseGameCommand)command)); } else if (command.GetType() == typeof(TriviaGameCommand)) { newSettings.SetCommand(new TriviaGameCommandModel((TriviaGameCommand)command)); } else if (command.GetType() == typeof(VendingMachineGameCommand)) { newSettings.SetCommand(new SpinGameCommandModel((VendingMachineGameCommand)command)); } else if (command.GetType() == typeof(VolcanoGameCommand)) { newSettings.SetCommand(new VolcanoGameCommandModel((VolcanoGameCommand)command)); } else if (command.GetType() == typeof(WordScrambleGameCommand)) { newSettings.SetCommand(new WordScrambleGameCommandModel((WordScrambleGameCommand)command)); } } newSettings.RemoveCommand(newSettings.GameQueueUserJoinedCommandID); newSettings.GameQueueUserJoinedCommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.GameQueueUserJoinedCommand); newSettings.RemoveCommand(newSettings.GameQueueUserSelectedCommandID); newSettings.GameQueueUserSelectedCommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.GameQueueUserSelectedCommand); newSettings.RemoveCommand(newSettings.GiveawayStartedReminderCommandID); newSettings.GiveawayStartedReminderCommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.GiveawayStartedReminderCommand); newSettings.RemoveCommand(newSettings.GiveawayUserJoinedCommandID); newSettings.GiveawayUserJoinedCommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.GiveawayUserJoinedCommand); newSettings.RemoveCommand(newSettings.GiveawayWinnerSelectedCommandID); newSettings.GiveawayWinnerSelectedCommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.GiveawayWinnerSelectedCommand); newSettings.RemoveCommand(newSettings.ModerationStrike1CommandID); newSettings.ModerationStrike1CommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.ModerationStrike1Command); newSettings.RemoveCommand(newSettings.ModerationStrike2CommandID); newSettings.ModerationStrike2CommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.ModerationStrike2Command); newSettings.RemoveCommand(newSettings.ModerationStrike3CommandID); newSettings.ModerationStrike3CommandID = SettingsV3Upgrader.ImportCustomCommand(newSettings, oldSettings.ModerationStrike3Command); foreach (UserQuoteViewModel quote in oldSettings.Quotes) { newSettings.Quotes.Add(quote.Model); } foreach (var kvp in oldSettings.UserData) { newSettings.UserData[kvp.Key] = kvp.Value; if (kvp.Value.EntranceCommand != null) { CustomCommandModel entranceCommand = new CustomCommandModel(kvp.Value.EntranceCommand); newSettings.SetCommand(entranceCommand); kvp.Value.EntranceCommandID = entranceCommand.ID; kvp.Value.EntranceCommand = null; } foreach (ChatCommand command in kvp.Value.CustomCommands) { UserOnlyChatCommandModel userCommand = new UserOnlyChatCommandModel(command, kvp.Key); newSettings.SetCommand(userCommand); kvp.Value.CustomCommandIDs.Add(userCommand.ID); } kvp.Value.CustomCommands.Clear(); } newSettings.GiveawayRequirementsSet = new RequirementsSetModel(oldSettings.GiveawayRequirements); foreach (OverlayWidgetModel widget in newSettings.OverlayWidgets.ToList()) { if (widget.Item is OverlayClipPlaybackItemModel) { newSettings.OverlayWidgets.Remove(widget); } else if (widget.Item is OverlayLeaderboardListItemModel) { if (((OverlayLeaderboardListItemModel)widget.Item).NewLeaderCommand != null) { CustomCommandModel command = new CustomCommandModel(((OverlayLeaderboardListItemModel)widget.Item).NewLeaderCommand); newSettings.SetCommand(command); ((OverlayLeaderboardListItemModel)widget.Item).LeaderChangedCommandID = command.ID; ((OverlayLeaderboardListItemModel)widget.Item).NewLeaderCommand = null; } } else if (widget.Item is OverlayProgressBarItemModel) { if (((OverlayProgressBarItemModel)widget.Item).GoalReachedCommand != null) { CustomCommandModel command = new CustomCommandModel(((OverlayProgressBarItemModel)widget.Item).GoalReachedCommand); newSettings.SetCommand(command); ((OverlayProgressBarItemModel)widget.Item).ProgressGoalReachedCommandID = command.ID; ((OverlayProgressBarItemModel)widget.Item).GoalReachedCommand = null; } } else if (widget.Item is OverlayStreamBossItemModel) { if (((OverlayStreamBossItemModel)widget.Item).NewStreamBossCommand != null) { CustomCommandModel command = new CustomCommandModel(((OverlayStreamBossItemModel)widget.Item).NewStreamBossCommand); newSettings.SetCommand(command); ((OverlayStreamBossItemModel)widget.Item).StreamBossChangedCommandID = command.ID; ((OverlayStreamBossItemModel)widget.Item).NewStreamBossCommand = null; } } else if (widget.Item is OverlayTimerItemModel) { if (((OverlayTimerItemModel)widget.Item).TimerCompleteCommand != null) { CustomCommandModel command = new CustomCommandModel(((OverlayTimerItemModel)widget.Item).TimerCompleteCommand); newSettings.SetCommand(command); ((OverlayTimerItemModel)widget.Item).TimerFinishedCommandID = command.ID; ((OverlayTimerItemModel)widget.Item).TimerCompleteCommand = null; } } } await ChannelSession.Services.Settings.Save(newSettings); } await ChannelSession.Services.FileService.CopyFile(oldSettings.SettingsFilePath, Path.Combine(SettingsV2Model.SettingsDirectoryName, "Old", oldSettings.SettingsFileName)); await ChannelSession.Services.FileService.CopyFile(oldSettings.SettingsLocalBackupFilePath, Path.Combine(SettingsV2Model.SettingsDirectoryName, "Old", oldSettings.SettingsLocalBackupFileName)); await ChannelSession.Services.FileService.CopyFile(oldSettings.DatabaseFilePath, Path.Combine(SettingsV2Model.SettingsDirectoryName, "Old", oldSettings.DatabaseFileName)); await ChannelSession.Services.FileService.DeleteFile(oldSettings.SettingsFilePath); await ChannelSession.Services.FileService.DeleteFile(oldSettings.SettingsLocalBackupFilePath); await ChannelSession.Services.FileService.DeleteFile(oldSettings.DatabaseFilePath); }
public static async Task <Result> ConnectUser(SettingsV2Model settings) { Result userResult = null; ChannelSession.Settings = settings; // Twitch connection Result <TwitchPlatformService> twitchResult = await TwitchPlatformService.Connect(ChannelSession.Settings.TwitchUserOAuthToken); if (twitchResult.Success) { ChannelSession.TwitchUserConnection = twitchResult.Value; userResult = twitchResult; } else { userResult = await ChannelSession.ConnectTwitchUser(ChannelSession.Settings.IsStreamer); } if (userResult.Success) { ChannelSession.TwitchUserNewAPI = await ChannelSession.TwitchUserConnection.GetNewAPICurrentUser(); if (ChannelSession.TwitchUserNewAPI == null) { return(new Result("Failed to get Twitch user data")); } ChannelSession.TwitchUserV5 = await ChannelSession.TwitchUserConnection.GetV5APIUserByLogin(ChannelSession.TwitchUserNewAPI.login); if (ChannelSession.TwitchUserV5 == null) { return(new Result("Failed to get V5 API Twitch user data")); } if (settings.TwitchBotOAuthToken != null) { twitchResult = await TwitchPlatformService.Connect(settings.TwitchBotOAuthToken); if (twitchResult.Success) { ChannelSession.TwitchBotConnection = twitchResult.Value; ChannelSession.TwitchBotNewAPI = await ChannelSession.TwitchBotConnection.GetNewAPICurrentUser(); if (ChannelSession.TwitchBotNewAPI == null) { return(new Result("Failed to get Twitch bot data")); } } else { settings.TwitchBotOAuthToken = null; return(new Result(success: true, message: "Failed to connect Twitch bot account, please manually reconnect")); } } } else { ChannelSession.Settings.TwitchUserOAuthToken = null; return(userResult); } return(userResult); }