public void Add_Post_ModelStateValid_RedirectToAction()
{
// Arrange
LoggerViewModel loggerViewModel = new LoggerViewModel()
{
Message = "TEST",
ObjectModel = new ObjectTestModel {
Type = "Add"
}
};
_manager.Setup(x => x.Add(loggerViewModel.Message, loggerViewModel.ObjectModel)).Verifiable();
// Act
var result = _controller.Add(loggerViewModel);
// Assert
Assert.IsAssignableFrom <RedirectToActionResult>(result);
_manager.Verify();
var redirectToAction = (RedirectToActionResult)result;
Assert.Equal("Add", redirectToAction.ActionName);
}
public DebugLogUserControl(LoggerViewModel loggerViewModel)
{
if (loggerViewModel == null)
{
throw new ArgumentNullException("loggerViewModel");
}
Logger = loggerViewModel;
InitializeComponent();
}
public static void Log(this string message)
{
var time = LoggerViewModel.TimeNow();
LoggerViewModel.Log.Add(new LogMessage(time, message));
if (LoggerViewModel.Log.Count > 200)
{
LoggerViewModel.Log.RemoveAt(0);
}
}
public void Log(string userId, string action, string localIp, Boolean loginStatus)
{
var model = new LoggerViewModel {
Action = action, LocalIp = localIp, LoginStatus = loginStatus, Date = DateTime.Now, UserId = userId
};
var date = model.Date;
UnitOfWork.LoggerService.Add(model);
UnitOfWork.Commit();
}
public LoggerView(LoggerViewModel vm)
{
DataContext = vm;
InitializeComponent();
// Scroll to end on new log entry
LogTextBox.TextChanged += (o, e) =>
{
(o as TextBox)?.ScrollToEnd();
};
}
protected override void OnNavigatedTo(NavigationEventArgs e)
{
if (e.Parameter is INotifier)
{
ViewModel = new LoggerViewModel(Dispatcher, e.Parameter as INotifier);
}
else
{
throw new NotSupportedException("Parameter not supported yet");
}
}
public IActionResult Add(LoggerViewModel viewModel)
{
if (ModelState.IsValid)
{
_loggerManager.Add(viewModel.Message, viewModel.ObjectModel);
return(RedirectToAction("Add"));
}
else
{
return(View(viewModel));
}
}
public SunbirdMBWindowViewModel(SunbirdMBGame sunbirdMBGame)
{
SunbirdMBGame = sunbirdMBGame;
C_Sort = new RelayCommand((o) => SortCubes());
C_Save = new RelayCommand((o) => SaveGame());
C_Exit = new RelayCommand((o) => ExitAppWithoutSaving());
CubeDesignerViewModel = new CubeDesignerViewModel(sunbirdMBGame);
decoCatalogViewModel = new DecoCatalogViewModel(sunbirdMBGame);
LoggerViewModel = new LoggerViewModel();
MainToolbarViewModel = new MainToolbarViewModel(this);
}
public Logger Edit(LoggerViewModel s)
{
var newModel = new Logger
{
Id = s.Id,
Action = s.Action,
Date = s.Date,
LocalIp = s.LocalIp,
LoginStatus = s.LoginStatus,
UserId = s.UserId,
}; Update(newModel);
return(newModel);
}
public static Logger MapLoggerViewModelToLogger(LoggerViewModel loggerViewModel)
{
if (loggerViewModel != null)
{
return(new Logger()
{
Id = loggerViewModel.Id,
Message = loggerViewModel.Message,
Sender = loggerViewModel.Sender,
LogDate = loggerViewModel.LogDate
});
}
else
{
return(null);
}
}
public void Add_Post_ModelStateInvalid_ReturnView()
{
// Arrange
LoggerViewModel loggerViewModel = new LoggerViewModel
{
Message = null,
ObjectModel = null
};
_controller.ModelState.AddModelError("Message", "Required");
// Act
var result = _controller.Add(loggerViewModel);
// Assert
Assert.IsAssignableFrom <ActionResult>(result);
}
public static IDebugPage CreateLogDebugPage(Logger logger, string title, bool register = true)
{
var dispatcher = SessionViewModel.Instance.ServiceProvider.Get <IDispatcherService>();
dispatcher.EnsureAccess();
// Activate all log levels
logger.ActivateLog(LogMessageType.Debug);
var loggerViewModel = new LoggerViewModel(SessionViewModel.Instance.ServiceProvider, logger);
var page = new DebugLogUserControl(loggerViewModel)
{
Title = title
};
if (register)
{
RegisterDebugPage(page);
}
return(page);
}
public AutonomyViewModel(ModelContainer ModelContainer)
{
modelContainer = ModelContainer;
LoggerViewModel = new LoggerViewModel(modelContainer.logger);
CameraViewModel = new CameraStreamViewModel();
DetectionListViewModel = new DetectionListViewModel(modelContainer);
StartAutonomyCommand = new RelayCommand(StartAutonomyAction, Allow);
StopAutonomyCommand = new RelayCommand(StopAutonomyAction, Allow);
modelContainer.dataContainer.Position.newDataCallback += (float x, float y, float z) => { RaisePropertyChanged("posX"); RaisePropertyChanged("posY"); RaisePropertyChanged("posZ"); };
modelContainer.dataContainer.Velocity.newNormCallback += (float x) => RaisePropertyChanged("Velocity");
modelContainer.dataContainer.Acceleration.newNormCallback += (float x) => RaisePropertyChanged("Acceleration");
modelContainer.modelStatus.taskManagerStatus.NewData += () => RaisePropertyChanged("TaskManagerStatus");
modelContainer.modelStatus.networkStatus.ConnectedToJetsonCallback += (bool val) => JetsonConnected = val;
modelContainer.modelStatus.AutonomyStatusCallback += (bool val) => AutonomyStatus = val;
modelContainer.dataContainer.Attitude.newDataCallback += (float x, float y, float z) => { Roll = x; Pitch = y; Heading = z; };
modelContainer.dataContainer.motorsData.newDataCallback += () => { RaisePropertyChanged("MotorsData"); };
}
public DebuggingViewModel(GameStudioViewModel editor, IDebugService debugService)
: base(editor.SafeArgument(nameof(editor)).ServiceProvider)
{
this.editor = editor;
this.debugService = debugService;
outputTitle = outputTitleBase;
BuildLog = new BuildLogViewModel(ServiceProvider);
LiveScriptingLog = new LoggerViewModel(ServiceProvider);
LiveScriptingLog.AddLogger(assemblyReloadLogger);
BuildProjectCommand = new AnonymousTaskCommand(ServiceProvider, () => BuildProject(false));
StartProjectCommand = new AnonymousTaskCommand(ServiceProvider, () => BuildProject(true));
CancelBuildCommand = new AnonymousCommand(ServiceProvider, () => { currentBuild?.Cancel(); });
LivePlayProjectCommand = new AnonymousTaskCommand(ServiceProvider, LivePlayProject);
ReloadAssembliesCommand = new AnonymousTaskCommand(ServiceProvider, ReloadAssemblies)
{
IsEnabled = false
};
ResetOutputTitleCommand = new AnonymousCommand(ServiceProvider, () => OutputTitle = outputTitleBase);
modifiedAssemblies = new Dictionary <PackageLoadedAssembly, ModifiedAssembly>();
trackAssemblyChanges = true;
assemblyTrackingCancellation = new CancellationTokenSource();
// Create script resolver
scriptsSorter = new ScriptSourceCodeResolver();
ServiceProvider.RegisterService(scriptsSorter);
assemblyReloadLogger.MessageLogged += (sender, e) => Dispatcher.InvokeAsync(() => OutputTitle = outputTitleBase + '*');
editor.Session.PropertyChanged += SessionPropertyChanged;
UpdateCommands();
Task.Run(async() =>
{
var watcher = await editor.StrideAssets.Code.ProjectWatcher;
await scriptsSorter.Initialize(editor.Session, watcher, assemblyTrackingCancellation.Token);
PullAssemblyChanges(watcher);
});
}
public void Initialize()
{
var version = Environment.OSVersion.Version;
IsWindows8OrGreater = (version.Major == 6 && version.Minor >= 2) || version.Major > 6;
Loggers = new ObservableCollection <LoggerBase>
{
new ItemLog(KanColleClient.Current.Proxy),
new ConstructionLog(KanColleClient.Current.Proxy),
new BattleLog(KanColleClient.Current.Proxy),
new MaterialsLog(KanColleClient.Current.Proxy),
};
Settings = new LoggerSettings(Loggers);
foreach (var logger in Loggers)
{
logger.Initialize();
}
this.viewmodel = new LoggerViewModel();
}
public DualSrtSubtitleService(LoggerViewModel logger)
{
Logger = logger;
}
public SubsenceService(LoggerViewModel logger)
{
this.logger = logger;
}
public LoggerView(LoggerViewModel loggerViewModel)
{
InitializeComponent();
DataContext = loggerViewModel;
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkProgressViewModel"/> class with multiple loggers.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> to use for this view model.</param>
/// <param name="loggers">The loggers to monitor.</param>
public WorkProgressViewModel(IViewModelServiceProvider serviceProvider, IEnumerable <Logger> loggers)
: base(serviceProvider)
{
Log = new LoggerViewModel(serviceProvider, loggers);
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkProgressViewModel"/> class with a single logger.
/// </summary>
/// <param name="serviceProvider">A service provider that can provide a <see cref="IDispatcherService"/> to use for this view model.</param>
/// <param name="logger">The logger to monitor.</param>
public WorkProgressViewModel(IViewModelServiceProvider serviceProvider, Logger logger)
: base(serviceProvider)
{
Log = new LoggerViewModel(serviceProvider, logger);
}
public PlexXmlService(LoggerViewModel logger)
{
Logger = logger;
}
public override void CreateLogger(LoggerConfig config)
{
if (CreateUI == false)
{
return;
}
_loggerConfig = config;
_loggerViewModel = new LoggerViewModel();
_loggerViewModel.StreamChanged += (sender, args) =>
{
OnStreamChanged(new StreamChangedEventArgs(args.Name, args.Enabled));
};
_filteredView = CollectionViewSource.GetDefaultView(_loggerViewModel.LogItems);
_filteredView.Filter = a => ((LoggerViewModel.LogItem)a).Stream.Enabled;
_filteredView.GroupDescriptions.Add(new PropertyGroupDescription("UpdateNumber"));
_loggerWindow = new LoggerWindow
{
Top = config.Top,
Left = config.Left,
Width = config.Width,
Height = config.Height
};
_loggerWindow.StreamsListView.DataContext = _loggerViewModel.Streams;
_loggerWindow.LogListView.DataContext = _filteredView;
_loggerWindow.SaveLogFile += (sender, args) => { SaveLogToFile(); };
_loggerWindow.EnableAllStreams += (sender, args) => { _loggerViewModel.EnableAllStreams(); };
_loggerWindow.DisableAllStreams += (sender, args) => { _loggerViewModel.DisableAllStreams(); };
_loggerWindow.IsVisibleChanged += (sender, args) => _loggerConfig.Visible = _loggerWindow.IsVisible;
_loggerWindow.LocationChanged += (sender, args) => _loggerLocationJustChanged = true;
_loggerWindow.SizeChanged += (sender, args) => _loggerLocationJustChanged = true;
_loggerWindow.SoloRequested += (sender, e) =>
{
foreach (var stream in _loggerViewModel.Streams)
{
if (stream != e.StreamItem)
{
stream.Enabled = false;
}
else
{
stream.Enabled = true;
}
}
};
if (_loggerConfig.Visible)
{
_loggerWindow.Show();
}
_windows.Add(_loggerWindow);
_loggerScrollViewer = GetDescendantByType(_loggerWindow.LogListView, typeof(ScrollViewer)) as ScrollViewer;
WindowHelper.EnsureOnScreen(_loggerWindow);
}
public AssSubtitleService(LoggerViewModel logger)
{
Logger = logger;
}
public PlexDataMapperService(LoggerViewModel logger)
{
}
