public async Task <ActionResult> Preferences(PreferencesViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
var user = await UserManager.FindByIdAsync(User.Identity.GetUserId());
if (user == null)
{
return(View(model));
}
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.TeamAssignment = model.TeamAssignment;
user.Email = model.Email; // TODO if email changed, may want to make the user re-confirm.
user.UserName = model.Email;
user.PayPalEmail = model.PayPalEmail;
user.VenmoAccount = model.VenmoAccount;
user.MobileLast4 = model.MobileLast4;
user.NotificationPreference = model.NotificationPreference;
var result = UserManager.Update(user);
if (result.Succeeded)
{
return(RedirectToAction("Index", new { Message = ManageMessageId.SavePreferencesSuccess }));
}
AddErrors(result);
// If we got this far, something failed, redisplay form
return(View(model));
}
public AssemblyEditorView(int viewId,
MessageManager msgMgr,
PreferencesViewModel preferences) :
base(viewId, "Assembly Editor", msgMgr)
{
m_Preferences = preferences;
m_EditorVm = new AssemblyEditorViewModel(viewId, msgMgr);
m_CreateNewFileCmd = new RelayCommand(() => NewFileAction(), true);
m_OpenFileCmd = new RelayCommand(() => LoadFileAction(), true);
m_SaveFileAsCmd = new RelayCommand(() => SaveFileAsAction(), true);
m_SaveFileCmd = new RelayCommand(() => SaveFileAction(), true);
m_ImportFileCmd = new RelayCommand(() => ImportFileAction(), true);
m_AssembleFileCmd = new RelayCommand <OutputTypes>((OutputTypes outputType) =>
AssembleActiveFileAction(outputType), true);
m_CloseAllFilesCmd = new RelayCommand(() => CloseAllFiles(), true);
InitializeComponent();
CreateDataBindings(m_EditorVm);
SubscribeToMessageType(MessageType.CreateFileRequest, m_CreateNewFileCmd);
SubscribeToMessageType(MessageType.OpenFileRequest, m_OpenFileCmd);
SubscribeToMessageType(MessageType.SaveFileRequest, m_SaveFileCmd);
SubscribeToMessageType(MessageType.SaveFileAsRequest, m_SaveFileAsCmd);
SubscribeToMessageType(MessageType.DisassembleFileRequest, m_ImportFileCmd);
SubscribeToMessageType(MessageType.AssembleFileRequest, m_AssembleFileCmd);
SubscribeToMessageType(MessageType.WindowClosingNotification, m_CloseAllFilesCmd);
}
public IActionResult ChangePrefs(PreferencesViewModel preferencesViewModel)
{
if (ModelState.IsValid)
{
if (tempUsername != null)
{
User currentUser = context.Users.Single(c => c.Username == tempUsername);
UserPrefs currentUserPrefs = context.Preferences.Single(p => p.ID == currentUser.UserPrefsID);
currentUserPrefs.UsersPrice = preferencesViewModel.UsersPrice;
currentUserPrefs.UsersArea = preferencesViewModel.UsersArea;
currentUserPrefs.UsersCareLevel = preferencesViewModel.UsersCareLevel;
context.Preferences.Update(currentUserPrefs);
context.SaveChanges();
return(Redirect("/HomePage/Browse"));
}
//TODO - return an error letting the user know that he needs to login or register first
string prefsError = "Please login or register to change preferences.";
ViewBag.error = prefsError;
ViewBag.n = 3;
return(View(preferencesViewModel));
}
return(View(preferencesViewModel));
}
public void SetUp()
{
var response = Substitute.For <IResponse>();
response.GetNextUrl().Returns("next-url");
_modelLoader = Substitute.For <ILoadModel>();
_modelSaver = Substitute.For <ISaveModel>();
_resource = new ResourceBuilder()
.WithDataTemplate()
.WithGroup("tariffFilterOptions")
.WithItem("tariffFilterOption")
.WithGroup("resultsOrder")
.WithItem("resultsOrder")
.WithGroup("limitToPaymentType")
.WithItem("paymentMethod")
.Build();
_viewModel = new PreferencesViewModel
{
PreferencesUri = _url,
PaymentMethod = _paymentMethod,
ResultsOrder = _resultOrders,
TariffFilterOption = _tariffFilterOption
};
_model = new PreferencesModel(_resource);
_modelLoader.Load <Resource, PreferencesModel>(_viewModel.PreferencesUri).Returns(_model);
_modelSaver.Save(_model).Returns(response);
_sut = new PreferencesController(_modelLoader, _modelSaver);
}
public void NewProject(int defaultPage)
{
ProjectViewModel projectViewModel = new ProjectViewModel(_context);
SetupViewModel setupViewModel = new SetupViewModel(_appModel.NewSetupModel(), _context);
ParticipantsViewModel participantsViewModel = new ParticipantsViewModel(_appModel.NewParticipantsModel(), _context);
PreferencesViewModel preferencesViewModel = new PreferencesViewModel(_appModel.NewPreferencesModel(), _context);
AlgorithmViewModel algorithmViewModel = new AlgorithmViewModel(_appModel.NewAlgorithmModel(), _context);
RunViewModel runViewModel = new RunViewModel(_appModel.NewRunModel(), _context);
runViewModel.CheckSolution += new EventHandler <int>(OnNewResultWindow);
_pages.Clear();
_pages.Add(projectViewModel);
_pages.Add(setupViewModel);
_pages.Add(participantsViewModel);
_pages.Add(preferencesViewModel);
_pages.Add(algorithmViewModel);
_pages.Add(runViewModel);
foreach (IPageTurn page in _pages)
{
page.NextPage += new EventHandler(Context_NextPage);
page.PreviousPage += new EventHandler(Context_PreviousPage);
}
//_context.ReadyChanged += new EventHandler(Context_ReadyChanged);
CurrentPage = _pages[defaultPage];
}
/// <summary>
/// Constructor of Preferences View
/// </summary>
/// <param name="dynamoViewModel"> Dynamo ViewModel</param>
public PreferencesView(DynamoViewModel dynamoViewModel)
{
//Clear the Saved Changes label and its corresponding tooltip when the Preferences Modal is opened
dynamoViewModel.PreferencesViewModel.SavedChangesLabel = string.Empty;
dynamoViewModel.PreferencesViewModel.SavedChangesTooltip = string.Empty;
DataContext = dynamoViewModel.PreferencesViewModel;
dynViewModel = dynamoViewModel;
InitializeComponent();
Dynamo.Logging.Analytics.TrackEvent(
Actions.Open,
Categories.Preferences);
//If we want the PreferencesView window to be modal, we need to assign the owner (since we created a new Style and not following the common Style)
this.Owner = Application.Current.MainWindow;
var viewModelTemp = DataContext as PreferencesViewModel;
if (viewModelTemp != null)
{
viewModel = viewModelTemp;
}
InitRadioButtonsDescription();
}
void TrayIconOnOpenPreferences()
{
var preferencesViewModel = new PreferencesViewModel(settingsProvider, new ScreenManager());
var preferencesView = new PreferencesView(preferencesViewModel);
preferencesView.Show();
}
public ActionResult Preferences()
{
var model = new PreferencesViewModel();
model.User = userRepository.GetSingle(User.Identity.GetUserId());
ViewBag.ActiveTab = "preferences";
return(View(model));
}
public PreferencesWindow(PreferencesViewModel systemPreferences)
{
InitializeComponent();
m_SystemPreferences = new PreferencesViewModel();
m_SystemPreferences.CloneValues(systemPreferences);
preferencesViewModelBindingSource.DataSource = m_SystemPreferences;
}
static void InitViewModel()
{
Uri uri = (Uri)App.Current.FindResource("appupdateurl");
PreferencesViewModel preferencesVM = ViewModelLocator.Instance.PreferencesVM;
preferencesVM.UpdateUri = uri;
}
public static void DisplayPreferences(DisplayPreviewModuleDataModel dataModel)
{
var viewModel = new PreferencesViewModel(dataModel);
var view = new PreferencesView {
DataContext = viewModel
};
view.ShowDialog();
}
public PreferencesWindow(PreferencesViewModel viewModel, IMessenger messenger)
{
_messenger = messenger;
InitializeComponent();
DataContext = viewModel;
messenger.Register <CloseWindowMessage>(this, CloseWindow);
}
public ActionResult Preferences()
{
var userId = User.Identity.GetUserId();
var user = _userService.Find(userId);
ViewBag.User = user;
PreferencesViewModel preferences = new PreferencesViewModel();
return(View(preferences));
}
public AssemblyTextBox(AssemblyFileViewModel avm,
PreferencesViewModel preferences) :
this()
{
m_ViewModel = avm;
m_ViewModel.FileErrors.CollectionChanged += OnFileErrorsChanged;
preferencesViewModelBindingSource.DataSource = preferences;
assemblyFileViewModelBindingSource.DataSource = avm;
m_FileTxtBox.SetHighlighting("Assembly");
}
/// <summary>
/// Builds the preference view models.
/// </summary>
/// <returns></returns>
public IList <PreferencesViewModel> BuildPreferenceViewModels()
{
var viewModels = new List <PreferencesViewModel>();
foreach (PreferenceCategory category in this.ConverterOptions.ConfigurationProvider.PreferenceCategories)
{
var viewModel = new PreferencesViewModel(this.ConverterOptions, new PreferencesView(), category);
viewModels.Add(viewModel);
}
return(viewModels);
}
private void NewViewModel()
{
_context = new ModelContext();
_model = new PreferencesModel(_context);
_viewModel = new PreferencesViewModel(_model, _context);
SetupModel setupModel = new SetupModel(_context);
setupModel.Initialize();
ParticipantsModel participantsModel = new ParticipantsModel(_context);
participantsModel.Initialize();
_viewModel.RefreshPage();
}
public PreferencesView(DynamoViewModel dynamoViewModel)
{
DataContext = new PreferencesViewModel(dynamoViewModel.Model.PreferenceSettings, dynamoViewModel.PythonScriptEditorTextOptions);
InitializeComponent();
//If we want the PreferencesView window to be modal, we need to assign the owner (since we created a new Style and not following the common Style)
this.Owner = Application.Current.MainWindow;
var viewModelTemp = DataContext as PreferencesViewModel;
if (viewModelTemp != null)
{
viewModel = viewModelTemp;
}
InitRadioButtonsDescription();
}
public FileEditor(AssemblyFileViewModel avm,
PreferencesViewModel preferences) :
this()
{
this.RecursiveRemove(m_FileTxt);
m_FileTxt.Dispose();
m_FileTxt = new AssemblyTextBox(avm, preferences)
{
BackColor = Color.DarkSalmon,
Dock = DockStyle.Fill,
Location = new Point(0, 0),
Name = "m_FileTxt",
Size = new Size(369, 204),
TabIndex = 0
};
splitContainer1.Panel1.Controls.Add(m_FileTxt);
m_LoggerTxtBox.DataBindings.Add(new Binding(nameof(m_LoggerTxtBox.Text), avm.Logger, nameof(avm.Logger.LogText)));
}
private static PreferencesViewModel InitializePreferencesViewModel()
{
var preferencesViewModel = new PreferencesViewModel();
foreach (MainCategory category in Enum.GetValues(typeof(MainCategory)))
{
var mainCategoryPreference = new MainCategoryPreferenceViewModel
{
MainCategory = category,
DisplayName = Regex.Replace(category.ToString(), "(\\B[A-Z])", " $1"),
Value = 1,
SubCategoryPreferences = CreateSubCategoryPreferenceViewModels(category)
};
preferencesViewModel.MainCategoryPreferences.Add(mainCategoryPreference);
}
return(preferencesViewModel);
}
void LoadPreferences()
{
PreferencesSettings settings = (PreferencesSettings)App.Current.FindResource("prefsettings");
PreferencesViewModel prefVM = ViewModelLocator.Instance.PreferencesVM;
prefVM.BassCode = settings.BassCode;
prefVM.BassUser = settings.BassUser;
prefVM.EnableProxy = settings.EnableProxy;
prefVM.Host = settings.Host;
prefVM.Port = settings.Port;
prefVM.ProxyDomain = settings.ProxyDomain;
prefVM.ProxyPassword = settings.ProxyPassword;
prefVM.ProxyUser = settings.ProxyUser;
prefVM.SelectedDevice = settings.SelectedDevice;
if (SettingsReloaded != null)
{
SettingsReloaded(settings, EventArgs.Empty);
}
}
public PreferencesViewModel GetPreferences()
{
PreferencesViewModel p = new PreferencesViewModel();
p.Country = _user.country;
p.CurrencyId = _user.currency_auto;
p.CurrencyName = "Australian Dollar"; // Need to import currency table into DAL
p.HomePageId = 0;
p.HomePageName = "Dashboard";
p.LanguageId = _user.language_auto;
p.LanguageName = _user.Language.Fulllanguage;
p.FullName = _user.username;
p.PhoneNumber = _user.phone_number;
p.PostCode = _user.postcode;
p.State = _user.state;
p.StreetAddress = _user.street1;
p.Suburb = _user.suburb;
p.UnitOfMeasurementName = _user.track_uom;
return(p);
}
/// <summary>
/// Constructor of Preferences View
/// </summary>
/// <param name="dynamoViewModel"> Dynamo ViewModel</param>
public PreferencesView(DynamoView dynamoView)
{
dynViewModel = dynamoView.DataContext as DynamoViewModel;
SetupPreferencesViewModel(dynViewModel);
DataContext = dynViewModel.PreferencesViewModel;
InitializeComponent();
Dynamo.Logging.Analytics.TrackEvent(
Actions.Open,
Categories.Preferences);
Owner = dynamoView;
if (DataContext is PreferencesViewModel viewModelTemp)
{
viewModel = viewModelTemp;
}
InitRadioButtonsDescription();
}
private void UpdatePreferences(PreferencesViewModel preferencesViewModel)
{
var personalData = TempData.GetPersonalDataList();
var preferences = personalData.Single(p => p.Id == preferencesViewModel.PersonId).Preferences;
preferences.CategoryPreferences.Clear();
var oldPreferences = TempData.GetPreferencesViewModel(preferencesViewModel.PersonId);
var oldMainPrefs = oldPreferences.MainCategoryPreferences;
var oldSubPrefs = oldPreferences.MainCategoryPreferences.SelectMany(m => m.SubCategoryPreferences).ToList();
foreach (var mainCategoryPreference in preferencesViewModel.MainCategoryPreferences)
{
List <SubCategoryPreferenceViewModel> subCategories;
if (Math.Abs(mainCategoryPreference.Value - 1.0) > 0.01)
{
oldMainPrefs.Single(m => m.MainCategory == mainCategoryPreference.MainCategory).Value = mainCategoryPreference.Value;
subCategories = mainCategoryPreference.SubCategoryPreferences;
}
else
{
subCategories = mainCategoryPreference.SubCategoryPreferences.Where(sub => Math.Abs(sub.Value - 1.0) > 0.01).ToList();
}
foreach (var subCategory in subCategories)
{
oldSubPrefs.Single(s => s.SubCategory == subCategory.SubCategory).Value = subCategory.Value;
preferences.CategoryPreferences.Add(new CategoryPreference
{
Preference = subCategory.Value * mainCategoryPreference.Value,
SubCategory = subCategory.SubCategory
});
}
}
TempData.SavePreferencesViewModel(oldPreferences, preferencesViewModel.PersonId);
TempData.SavePersonalDataList(personalData);
}
void SavePreferences()
{
PreferencesSettings settings = (PreferencesSettings)App.Current.FindResource("prefsettings");
PreferencesViewModel prefVM = ViewModelLocator.Instance.PreferencesVM;
settings.BassCode = prefVM.BassCode;
settings.BassUser = prefVM.BassUser;
settings.EnableProxy = prefVM.EnableProxy;
settings.Host = prefVM.Host;
settings.Port = prefVM.Port;
settings.ProxyDomain = prefVM.ProxyDomain;
settings.ProxyPassword = prefVM.ProxyPassword;
settings.ProxyUser = prefVM.ProxyUser;
settings.SelectedDevice = prefVM.SelectedDevice;
settings.Save();
if (SettingsSaved != null)
{
SettingsSaved(settings, EventArgs.Empty);
}
}
/// <summary>
/// Constructor of Preferences View
/// </summary>
/// <param name="dynamoViewModel"> Dynamo ViewModel</param>
public PreferencesView(DynamoView dynamoView)
{
dynViewModel = dynamoView.DataContext as DynamoViewModel;
SetupPreferencesViewModel(dynViewModel);
DataContext = dynViewModel.PreferencesViewModel;
InitializeComponent();
Dynamo.Logging.Analytics.TrackEvent(
Actions.Open,
Categories.Preferences);
Owner = dynamoView;
if (DataContext is PreferencesViewModel viewModelTemp)
{
viewModel = viewModelTemp;
}
InitRadioButtonsDescription();
//We need to store the ScaleFactor value in a temporary variable always when the Preferences dialog is created.
scaleValue = dynViewModel.ScaleFactorLog;
}
public PreferencesWindow(IWritableOptions <AppSettings> appSettingsOpt,
IList <CultureInfo> allCultureInfos,
ObservableCollection <PluginStatus> pluginStatus,
IFilenameProcessor filenameProcessor)
{
InitializeComponent();
_vm = new PreferencesViewModel();
_appSettingsOpt = appSettingsOpt;
// Settings
_vm.RootDirectory = _appSettingsOpt.Value.RootDirectory;
// Language list
_vm.LanguageList = allCultureInfos;
// Plugin status
_vm.PluginList = pluginStatus;
// Regular expressions
_vm.RegExList = new ObservableCollection <RegExTVItem>();
foreach (var expr in _appSettingsOpt.Value.RegExTV)
{
_vm.RegExList.Add(new RegExTVItem()
{
Expression = expr
});
}
// Filename processor
_filenameProcessor = filenameProcessor;
_vm.SampleText = "In Living Color - S01E01 - Pilot [Unknown] [1990-04-15]";
DataContext = _vm;
}
public PreferencesViewModel GetPreferencesViewModel(int memberID)
{
PreferencesViewModel result = new PreferencesViewModel();
return result;
}
public PreferencesViewModelScenario()
{
ViewModel = new PreferencesViewModel(ApplicationSettings);
}
public PreferencesView(PreferencesViewModel viewModel)
{
DataContext = viewModel;
InitializeComponent();
}
public PreferencesView(PreferencesViewModel viewModel)
{
InitializeComponent();
DataContext = viewModel;
}
public static PreferencesViewModel SavePreferencesViewModel(this TempDataDictionary tempData, PreferencesViewModel preferences, int personId)
{
tempData[PreferencesKey + personId] = preferences;
return(preferences);
}
public IActionResult ChangePrefs()
{
PreferencesViewModel preferencesViewModel = new PreferencesViewModel();
return(View(preferencesViewModel));
}
