public void CreateLogViewWhichIsActive()
{
StumpMother mother = new StumpMother();
ILogView view = MockRepository.GenerateMock <ILogView>();
ILogMonitor monitor = mother.LogMonitors[0];
mother.LogUpdaterQueue.Expect(lr => lr.FetchLogContents("d:/log1.txt", null))
.Constraints(Is.Equal("d:/log1.txt"), Is.Anything())
.Do((Action <string, LogContentsFetchedCallback>) delegate { view.ShowLogContents("logContents1"); });
view.Expect(v => v.IsLogDisplayActive).Return(true);
view.Expect(v => v.ShowLogContents("logContents1"));
monitor.Expect(m => m.StartMonitoring("d:/log1.txt", null, null, null, null))
.IgnoreArguments().Repeat.Once();
monitor.Expect(m => m.StopMonitoring()).Repeat.Once();
using (LogPresenter presenter = new LogPresenter(
view,
monitor,
mother.LogUpdaterQueue,
mother.Workspace.LogFiles[0]))
{
}
view.VerifyAllExpectations();
monitor.VerifyAllExpectations();
}
public void CreateLogViewWhichIsNotActive()
{
StumpMother mother = new StumpMother();
ILogView view = MockRepository.GenerateMock <ILogView>();
ILogMonitor monitor = mother.LogMonitors[0];
view.Expect(v => v.IsLogDisplayActive).Return(false);
monitor.Expect(m => m.StartMonitoring("d:/log1.txt", null, null, null, null))
.IgnoreArguments().Repeat.Once();
monitor.Expect(m => m.StopMonitoring()).Repeat.Once();
using (LogPresenter presenter = new LogPresenter(
view,
monitor,
mother.LogUpdaterQueue,
mother.Workspace.LogFiles[0]))
{
}
view.AssertWasNotCalled(v => v.ShowLogContents("logContents1"));
view.VerifyAllExpectations();
monitor.VerifyAllExpectations();
}
public async Task SendAsync(ILogView log)
{
Copy(log);
var message = new EmailMessage
{
Body = s_resources.GetString("MessageBody"),
Subject = string.Format(s_resources.GetString("MessageSubject"), log.Id, File.ReadAllText("version.txt").Trim())
};
message.To.Add(new EmailRecipient(s_resources.GetString("MessageTo"), s_resources.GetString("MessageToName")));
using (var ms = new InMemoryRandomAccessStream())
{
using (var writer = new DataWriter(ms.GetOutputStreamAt(0)))
{
writer.WriteString(log.Log);
await writer.StoreAsync();
await writer.FlushAsync();
var data = RandomAccessStreamReference.CreateFromStream(ms);
var attachment = new EmailAttachment($"{log.Id}.log", data);
message.Attachments.Add(attachment);
await EmailManager.ShowComposeNewEmailAsync(message);
}
}
}
/// <summary>
/// Initializes a new instance of the PresenterBuilder class.
/// </summary>
/// <param name="mainView">IMainView.</param>
/// <param name="logView">ILogView.</param>
/// <param name="optionsView">IOptionsView.</param>
/// <param name="propertiesView">IPropertiesView.</param>
/// <exception cref="ArgumentNullException">mainView is null.</exception>
/// <exception cref="ArgumentNullException">logView is null.</exception>
/// <exception cref="ArgumentNullException">optionsView is null.</exception>
/// <exception cref="ArgumentNullException">propertiesView is null.</exception>
public PresenterBuilder(IMainView mainView,
ILogView logView,
IOptionsView optionsView,
IPropertiesView propertiesView)
{
if (mainView == null)
{
throw new ArgumentNullException("mainView",
Resources.ArgumentNullException);
}
if (logView == null)
{
throw new ArgumentNullException("logView",
Resources.ArgumentNullException);
}
if (optionsView == null)
{
throw new ArgumentNullException("optionsView",
Resources.ArgumentNullException);
}
if (propertiesView == null)
{
throw new ArgumentNullException("propertiesView",
Resources.ArgumentNullException);
}
_viewType = ViewType.Forms;
_mainView = mainView;
_logView = logView;
_optionsView = optionsView;
_propertiesView = propertiesView;
}
public LoggingPageViewModel(ILogView logView, IClipboard <ILogView> clipboard, IMailClient <ILogView> mailClient)
{
LogView = logView;
SendCommand = new DelegateCommand(() => mailClient.SendAsync(LogView));
CopyCommand = new DelegateCommand(() => clipboard.Copy(LogView));
}
public void TestInitialize()
{
_service = Substitute.For <ILogService>();
_view = Substitute.For <ILogView>();
_sut = new LogPresenter(_service);
_sut.Bind(_view);
}
/// <summary>
/// Initializes a new instance of the LogViewPresenterBase class.
/// </summary>
/// <param name="logView">Log view.</param>
/// <param name="mainView">Main view.</param>
/// <param name="applicationOptionsController">ApplicationOptionsController.</param>
/// <param name="fileWatcherController">FileWatcherController.</param>
/// <param name="formatter">Log formatter.</param>
/// <param name="viewUpdateInterval">View update interval.</param>
/// <param name="logMessageSize">Log message size.</param>
/// <exception cref="ArgumentNullException">Log view is null.</exception>
/// <exception cref="ArgumentNullException">fileWatcherController is null.</exception>
/// <exception cref="ArgumentNullException">formatter is null.</exception>
public LogViewPresenter(ILogView logView,
IMainView mainView,
ApplicationOptionsController applicationOptionsController,
FileWatcherController fileWatcherController,
IFormatter formatter,
double viewUpdateInterval,
int logMessageSize)
: base(fileWatcherController, formatter, logMessageSize)
{
if (logView == null)
{
throw new ArgumentNullException("logView",
Resources.ArgumentNullException);
}
if (mainView == null)
{
throw new ArgumentNullException("mainView",
Resources.ArgumentNullException);
}
if (applicationOptionsController == null)
{
throw new ArgumentNullException("applicationOptionsController",
Resources.ArgumentNullException);
}
if (fileWatcherController == null)
{
throw new ArgumentNullException("fileWatcherController",
Resources.ArgumentNullException);
}
if (formatter == null)
{
throw new ArgumentNullException("formatter",
Resources.ArgumentNullException);
}
_logView = logView;
_mainView = mainView;
_applicationOptionsController = applicationOptionsController;
// Check if view interval is less than default value.
if (viewUpdateInterval < 100)
{
_updateTimer.Interval = 100;
}
else
{
_updateTimer.Interval = viewUpdateInterval;
}
SubscribeToLogViewEvents();
SubscribeToMainViewEvents();
SubscribeToApplicationOptionsControllerEvents();
// Subscribe to timer event. (updates view).
_updateTimer.Elapsed += new ElapsedEventHandler(OnElapsed);
// Set synchronization context for running events in main thread.
SetSynchronizationContext();
}
public LogsViewModel(ILogView view, IUnityContainer container)
{
this.view = view;
this.container = container;
view.Loaded += OnLoaded;
view.Unloaded += OnUnloaded;
}
public static void AddReader(ILogView LogReader)
{
LogReaders.AddLast(LogReader);
foreach (var LogLines in LogContent)
{
LogReader.WriteLine(LogLines);
}
}
public static void Wire(ILogView view, ISubscriber bus)
{
var adapter = new LogController(view);
// have our logger subscribe to the "main event loop"
// of the application so it can see all Messages (Actions/Events, etc.)
// the "bus" is part of our in-memory UI messaging architecture (SEDA)
bus.Subscribe(adapter);
}
public DeleteMessageCommand(ILogView view)
{
_view = view;
Image = Resources.Email_Delete24;
Text = CultureService.Instance.GetString(CultureText.menuItem_Delete_Text);
EventAggregator.Instance.Subscribe <LogSelectionChangedAppEvent>(e =>
{
Enabled = e.SelectedItems.Count > 0;
});
}
public static void DeregisterLogView(ILogView logview)
{
if (!LogViewDictionary.ContainsKey(logview.GetViewKey()))
{
ActualLogger.Error("Cannot unregister logview since no log view found with this key");
}
else
{
LogViewDictionary.Remove(logview.GetViewKey());
}
}
public static void RegisterLogView(ILogView logview)
{
if (!LogViewDictionary.ContainsKey(logview.GetViewKey()))
{
LogViewDictionary.Add(logview.GetViewKey(), logview);
}
else
{
ActualLogger.Error("The log view is already registered");
}
}
public LogEntriesController(IEFRepository repository, ILogView view)
: base(repository, view)
{
this._helper = DateHelper.GetInstance();
this._logView = view;
this._logView.GetLogStatistics = this.GetLogStatistics;
this._logView.GetCalendarData = this.GetCalendarData;
this._logView.GetRememberedSetting = this.GetRememberedSetting;
this._logView.SetRememberedSetting = this.SetRememberedSetting;
this._logView.GetRememberedDate = this.GetRememberedDate;
this._logView.SetRememberedDate = this.SetRememberedDate;
}
private async Task <IStorageItem> CreateFileAsync(ILogView view)
{
var file = await ApplicationData.Current.TemporaryFolder.CreateFileAsync($"{view.Id}.log", CreationCollisionOption.GenerateUniqueName);
using (var stream = await file.OpenStreamForWriteAsync())
using (var writer = new StreamWriter(stream))
{
await writer.WriteAsync(view.Log);
}
return(file);
}
public LogPresenter(ILogView view)
{
this._context = SynchronizationContext.Current;
this._view = view;
// событие смены типа логирования в выпадающем списке
this._view.LogTypeChanged += this.ViewOnLogTypeChanged;
// по умолчанию всегда загружаем логи из БД
this._service = new Service(new DbLogService());
this.LoadLogs();
Task.Factory.StartNew(this.GetLoggingTypeFromServer);
Task.Factory.StartNew(this.LoadLast);
}
public void SetCurrentFile(FileViewContext ctx)
{
if (ctx != null)
{
Logger.logDebug("Current file changed to " + ctx.LogView.FileName);
lock (this.paintLock)
{
this.logView = ctx.LogView;
this.logPaintContext = ctx.LogPaintContext;
}
this.SetColumnizer(ctx.LogView.CurrentColumnizer);
}
else
{
this.logView = null;
this.logPaintContext = null;
}
UpdateView();
}
public LogPresenter(ILogView view)
{
_view = view;
List <string> logs = new List <string>();
logs.Add("------ТС1----------------------------------------------------------------------------");
logs.AddRange(AppContext.Vehicles[0].LogString);
logs.Add("------ТС2----------------------------------------------------------------------------");
logs.AddRange(AppContext.Vehicles[1].LogString);
logs.Add("------ТС3----------------------------------------------------------------------------");
logs.AddRange(AppContext.Vehicles[2].LogString);
logs.Add("------ТС4----------------------------------------------------------------------------");
logs.AddRange(AppContext.Vehicles[3].LogString);
logs.Add("------ТС5----------------------------------------------------------------------------");
logs.AddRange(AppContext.Vehicles[4].LogString);
_view.SetLogs(logs);
//_view.SetLogs(AppContext.Vehicles[1].LogString);
//_view.SetLogs(AppContext.Vehicles[2].LogString);
//_view.SetLogs(AppContext.Vehicles[3].LogString);
//_view.SetLogs(AppContext.Vehicles[4].LogString);
}
public virtual bool Copy(ILogView log)
{
var datapackage = new DataPackage();
datapackage.SetDataProvider(StandardDataFormats.Text, request =>
{
request.SetData(log.Log);
});
datapackage.SetDataProvider(StandardDataFormats.StorageItems, async request =>
{
var deferral = request.GetDeferral();
request.SetData(new IStorageItem[] { await CreateFileAsync(log) });
deferral.Complete();
});
AddToClipboardAsync(datapackage, autoClear: false);
return(true);
}
public void StopMonitoring()
{
StumpMother mother = new StumpMother();
ILogView view = MockRepository.GenerateMock <ILogView>();
ILogMonitor monitor = mother.LogMonitors[0];
view.Expect(v => v.IsLogDisplayActive).Return(true);
view.Expect(v => v.IndicateLogFileNotMonitored());
using (LogPresenter presenter = new LogPresenter(
view,
monitor,
mother.LogUpdaterQueue,
mother.Workspace.LogFiles[0]))
{
// turn off monitoring
presenter.OnMonitoringEnabledToggled();
}
view.VerifyAllExpectations();
monitor.VerifyAllExpectations();
}
public LogPresenter(
ILogView view,
ILogMonitor logMonitor,
ILogUpdaterQueue logUpdaterQueue,
MonitoredLogFile logFile)
{
this.view = view;
this.logUpdaterQueue = logUpdaterQueue;
this.logFile = logFile;
this.monitor = logMonitor;
view.MonitoringEnabled = logFile.IsActive;
if (logFile.IsActive)
{
StartMonitor();
}
if (view.IsLogDisplayActive)
{
OnLogDisplayActivated();
}
}
public void CreateLogViewWhichIsActiveButNotMonitored()
{
StumpMother mother = new StumpMother();
mother.Workspace.LogFiles[0].IsActive = false;
ILogView view = MockRepository.GenerateMock <ILogView>();
ILogMonitor monitor = mother.LogMonitors[0];
view.Expect(v => v.IsLogDisplayActive).Return(true);
view.Expect(v => v.IndicateLogFileNotMonitored());
using (LogPresenter presenter = new LogPresenter(
view,
monitor,
mother.LogUpdaterQueue,
mother.Workspace.LogFiles[0]))
{
}
monitor.AssertWasNotCalled(m => m.StartMonitoring(null, null, null, null, null));
view.VerifyAllExpectations();
monitor.VerifyAllExpectations();
}
public LogPresenter(ILogView view)
{
logFilter = new LogFilterModel();
logBll = new SysLogBll();
this.view = view;
}
public void TestCleanup()
{
_service = null;
_view = null;
_sut = null;
}
public static void RemoveReader(ILogView LogReader)
{
LogReaders.Remove(LogReader);
}
public void SetCurrentFile(FileViewContext ctx)
{
if (ctx != null)
{
Logger.logDebug("Current file changed to " + ctx.LogView.FileName);
lock (this.paintLock)
{
this.logView = ctx.LogView;
this.logPaintContext = ctx.LogPaintContext;
}
this.SetColumnizer(ctx.LogView.CurrentColumnizer);
}
else
{
this.logView = null;
this.logPaintContext = null;
}
UpdateView();
}
public void SetView(ILogView logView)
{
this.view = logView;
this.view.Initialize();
}
protected override void OnViewLoaded(object view)
{
_view = (ILogView)view;
Log.AddReader(_view);
_view.ScrollToEnd();
}
public virtual void SetServiceProvider(IServiceProvider serviceProvider,
DThreadProgress threadProgress, SidePanel sidePanel,
BaseItem item, string id, float ratio,
BaseDiagramOptions options)
{
_windowManager = (IWindowManager)serviceProvider.GetService(typeof(IWindowManager));
_logView = (ILogView)serviceProvider.GetService(typeof(ILogView));
_projectBrowser = (IProjectBrowser)serviceProvider.GetService(typeof(IProjectBrowser));
_threadProgress = threadProgress;
_sidePanel = sidePanel;
_activeItem = item;
_id = id;
_ratio = ratio;
_options = options;
}
internal FileViewContext(ILogPaintContext logPaintContext, ILogView logView)
{
this.LogPaintContext = logPaintContext;
this.LogView = logView;
}
public void SetServiceProvider(IServiceProvider serviceProvider)
{
_projectBrowser = (IProjectBrowser)serviceProvider.GetService(typeof(IProjectBrowser));
_logView = (ILogView)serviceProvider.GetService(typeof(ILogView));
}
/// <summary>
/// Initializes a new instance of the LogViewPresenterBase class.
/// </summary>
/// <param name="logView">Log view.</param>
/// <param name="mainView">Main view.</param>
/// <param name="applicationOptionsController">ApplicationOptionsController.</param>
/// <param name="fileWatcherController">FileWatcherController.</param>
/// <param name="formatter">Log formatter.</param>
/// <param name="viewUpdateInterval">View update interval.</param>
/// <param name="logMessageSize">Log message size.</param>
/// <exception cref="ArgumentNullException">Log view is null.</exception>
/// <exception cref="ArgumentNullException">fileWatcherController is null.</exception>
/// <exception cref="ArgumentNullException">formatter is null.</exception>
public LogViewPresenter(ILogView logView,
IMainView mainView,
ApplicationOptionsController applicationOptionsController,
FileWatcherController fileWatcherController,
IFormatter formatter,
double viewUpdateInterval,
int logMessageSize)
: base(fileWatcherController, formatter, logMessageSize)
{
if (logView == null)
{
throw new ArgumentNullException("logView",
Resources.ArgumentNullException);
}
if (mainView == null)
{
throw new ArgumentNullException("mainView",
Resources.ArgumentNullException);
}
if (applicationOptionsController == null)
{
throw new ArgumentNullException("applicationOptionsController",
Resources.ArgumentNullException);
}
if (fileWatcherController == null)
{
throw new ArgumentNullException("fileWatcherController",
Resources.ArgumentNullException);
}
if (formatter == null)
{
throw new ArgumentNullException("formatter",
Resources.ArgumentNullException);
}
_logView = logView;
_mainView = mainView;
_applicationOptionsController = applicationOptionsController;
// Check if view interval is less than default value.
if (viewUpdateInterval < 100)
{
_updateTimer.Interval = 100;
}
else
{
_updateTimer.Interval = viewUpdateInterval;
}
SubscribeToLogViewEvents();
SubscribeToMainViewEvents();
SubscribeToApplicationOptionsControllerEvents();
// Subscribe to timer event. (updates view).
_updateTimer.Elapsed += new ElapsedEventHandler(OnElapsed);
// Set synchronization context for running events in main thread.
SetSynchronizationContext();
}
LogController(ILogView view)
{
_view = view;
}
internal FileViewContext(ILogPaintContext logPaintContext, ILogView logView)
{
this.LogPaintContext = logPaintContext;
this.LogView = logView;
}
public virtual void SetServiceProvider(IServiceProvider serviceProvider)
{
_serviceProvider = serviceProvider;
_windowManager = (IWindowManager)serviceProvider.GetService(typeof(IWindowManager));
_projectBrowser = (IProjectBrowser)serviceProvider.GetService(typeof(IProjectBrowser));
_logView = (ILogView)serviceProvider.GetService(typeof(ILogView));
_menuManager = (IMenuManager)serviceProvider.GetService(typeof(IMenuManager));
_sidePanel.SetServiceProvider(_serviceProvider);
}
