private async Task LoadMonitors()
{
var monitorsTask = Task.Run(() => MonitorManager.EnumerateMonitors().ToList());
var displayList = await monitorsTask;
_model.SetDisplayList(displayList);
}
void Run()
{
var tmp = new List <StatItem>();
var r = new Random(1);
while (true)
{
tmp.Clear();
Statistic.Clear();
tmp = MonitorManager.GetCurrencyStatictic(TickPeriod.ToInt(), ConnectionString);
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.RUB));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.USD));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.EUR));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.CHF));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.JPY));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.GBP));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.CAD));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.CNY));
Statistic.Add(GetByCurr(tmp, CurrencyTypeEnum.BRL));
ClearStatServer();
StatServer = MonitorManager.GetServerStatictic(TickPeriod.ToInt(), ConnectionString);
RiseShowValueAndPriceEvent();
Thread.Sleep(TickPeriod.ToInt());
}
}
public void AdjustMonitorSettings(MonitorManager manager)
{
MainWindow.Trace("AMS: " + BaseUrl + "; " + Channel);
int light;
try
{
light = GetLastLightLevel();
}
catch (Exception e)
{
MainWindow.Error("Cannot GetLastLightLevel() from ThingSpeakDataFeed.AdjustMonitorSettings() because: " + e);
return;
}
// Ignore small changes that would cause monitor Brightness flickering. Change the Brightness only past certain difference treshold
if (Math.Abs(light - lastLight) < 2)
{
return;
}
MainWindow.Trace("Light: " + light + " --> " + ThingSpeakLightConverter.Eval(light));
lastLight = light;
manager.MasterMonitor.Brightness = (int)ThingSpeakLightConverter.Eval(light);
//Manager.MasterMonitor.Contrast = monitorSettingsByLightLevel[light].Contrast;
//Manager.MasterMonitor.Temperature = monitorSettingsByLightLevel[light].Temperature;
}
public async Task SetStatusAndResetLastTestCycleIntervalAsync(
MonitorStatus oldStatus,
MonitorStatus newStatus)
{
// Arrange
var monitor = new NcMonitor
{
StatusId = (int)oldStatus,
LastTestCycleInterval = new TimeSpan(2, 3, 4),
};
var monitorRepo = new Mock <IMonitorRepository>();
IMonitorManager monitorManager = new MonitorManager(
It.IsAny <IChannelRepository>(),
monitorRepo.Object,
It.IsAny <IRecordRepository>(),
It.IsAny <IScenarioRepository>());
// Act
await monitorManager.SetStatusAndResetLastTestCycleIntervalAsync(
monitor,
newStatus);
// Assert
monitorRepo.Verify(x => x.UpdateAsync(monitor), Times.Once());
Assert.Equal(new TimeSpan?(), monitor.LastTestCycleInterval);
Assert.Equal(newStatus, monitor.StatusEnum());
}
///GENMHASH:F886A4914B553C095A7AE17389D27E77:FA5F578A5F3D9A0CDDD31A0A42192F9F
internal MetricDefinitionImpl(MetricDefinition innerModel, MonitorManager monitorManager)
: base(innerModel)
{
this.myManager = monitorManager;
this.inner = innerModel;
this.name = (inner.Name == null) ? null : new LocalizableStringImpl(inner.Name);
}
public async Task SetLastTestCycleIntervalsAsync()
{
// Arrange
var expectedTimeSpan = new TimeSpan(2, 40, 42);
var expectedStatus = MonitorStatus.OK;
var monitor = new NcMonitor
{
LastTestCycleInterval = It.IsAny <TimeSpan>(),
StatusId = (int)expectedStatus,
};
var monitorRepo = new Mock <IMonitorRepository>();
IMonitorManager monitorManager = new MonitorManager(
It.IsAny <IChannelRepository>(),
monitorRepo.Object,
It.IsAny <IRecordRepository>(),
It.IsAny <IScenarioRepository>());
// Act
await monitorManager.SetLastTestCycleIntervalsAsync(
monitor, expectedTimeSpan);// TimeSpan je struct, neni potreba vytvaret novou referenci
// Assert
monitorRepo.Verify(x => x.UpdateAsyncWithoutResetTestCycleInterval(monitor), Times.Once());
Assert.Equal(expectedTimeSpan, monitor.LastTestCycleInterval);
Assert.Equal(expectedStatus, monitor.StatusEnum());
}
private Azure(RestClient restClient, string subscriptionId, string tenantId, IAuthenticated authenticated)
{
resourceManager = ResourceManager.Fluent.ResourceManager.Authenticate(restClient).WithSubscription(subscriptionId);
storageManager = StorageManager.Authenticate(restClient, subscriptionId);
computeManager = ComputeManager.Authenticate(restClient, subscriptionId);
networkManager = NetworkManager.Authenticate(restClient, subscriptionId);
batchManager = BatchManager.Authenticate(restClient, subscriptionId);
keyVaultManager = KeyVaultManager.Authenticate(restClient, subscriptionId, tenantId);
trafficManager = TrafficManager.Fluent.TrafficManager.Authenticate(restClient, subscriptionId);
dnsZoneManager = DnsZoneManager.Authenticate(restClient, subscriptionId);
sqlManager = SqlManager.Authenticate(restClient, subscriptionId);
redisManager = RedisManager.Authenticate(restClient, subscriptionId);
cdnManager = CdnManager.Authenticate(restClient, subscriptionId);
appServiceManager = AppServiceManager.Authenticate(restClient, subscriptionId, tenantId);
searchManager = SearchManager.Authenticate(restClient, subscriptionId);
serviceBusManager = ServiceBusManager.Authenticate(restClient, subscriptionId);
containerInstanceManager = ContainerInstanceManager.Authenticate(restClient, subscriptionId);
registryManager = RegistryManager.Authenticate(restClient, subscriptionId);
containerServiceManager = ContainerServiceManager.Authenticate(restClient, subscriptionId);
cosmosDBManager = CosmosDBManager.Authenticate(restClient, subscriptionId);
authorizationManager = AuthorizationManager.Authenticate(restClient, subscriptionId);
msiManager = MsiManager.Authenticate(restClient, subscriptionId);
batchAIManager = BatchAIManager.Authenticate(restClient, subscriptionId);
monitorManager = MonitorManager.Authenticate(restClient, subscriptionId);
eventHubManager = EventHubManager.Authenticate(restClient, subscriptionId);
SubscriptionId = subscriptionId;
this.authenticated = authenticated;
}
private void MaximizeWindow(bool maximize)
{
if (!MaximizeBox || !ControlBox)
{
return;
}
_maximized = maximize;
if (maximize)
{
IntPtr _monitorHandle = Native.MonitorFromWindow(Handle, MONITOR_DEFAULTTONEAREST);
MonitorManager _monitorInfo = new MonitorManager();
Native.GetMonitorInfo(new HandleRef(null, _monitorHandle), _monitorInfo);
_previousSize = Size;
_previousLocation = Location;
Size = new Size(_monitorInfo.WorkingArea.Width, _monitorInfo.WorkingArea.Height);
Location = new Point(_monitorInfo.WorkingArea.Left, _monitorInfo.WorkingArea.Top);
}
else
{
Size = _previousSize;
Location = _previousLocation;
}
}
private void LoadMonitorSettingsInto(MonitorManager monitorManager, Monitor monitor)
{
String prefix = GetConfigPrefix(monitorManager, monitor);
if (monitor.SupportsBrightness)
{
int brightness = config.GetInt(prefix + ConfigKeyMonitorBrightness, -1);
if (brightness != -1)
{
monitor.Brightness = brightness;
}
}
if (monitor.SupportsContrast)
{
int contrast = config.GetInt(prefix + ConfigKeyMonitorContrast, -1);
if (contrast != -1)
{
monitor.Contrast = contrast;
}
}
if (monitor.SupportsTemperature)
{
int temperature = config.GetInt(prefix + ConfigKeyMonitorTemperature, -1);
if (temperature != -1)
{
monitor.Temperature = temperature;
}
}
}
private void AddMonitorManager(TabItem tab, MonitorManager manager)
{
Trace("");
Trace("Adding monitor Manager: " + manager.GetType().Name);
StackPanel tabContent = new StackPanel()
{
Orientation = Orientation.Vertical
};
tab.Content = tabContent;
MonitorSliders masterSlider = new MonitorSliders(manager.MasterMonitor);
tabContent.Children.Add(masterSlider);
int supportBrightness = 0;
int supportContrast = 0;
int supportTemperature = 0;
List <Monitor> monitors = manager.GetMonitorsList();
foreach (Monitor monitor in monitors)
{
Trace("- " + monitor.ToStringDbg());
MonitorSliders slider = new MonitorSliders(monitor);
tabContent.Children.Add(slider);
if (monitor.SupportsBrightness)
{
supportBrightness++;
}
if (monitor.SupportsContrast)
{
supportContrast++;
}
if (monitor.SupportsTemperature)
{
supportTemperature++;
}
}
// "< 2" or "== 0" whichever works better
if (supportBrightness == 0)
{
masterSlider.BrightnessSliderLabel.Visibility = Visibility.Collapsed;
masterSlider.BrightnessSlider.Visibility = Visibility.Collapsed;
masterSlider.BrightnessSliderText.Visibility = Visibility.Collapsed;
}
if (supportContrast == 0)
{
masterSlider.ContrastSliderLabel.Visibility = Visibility.Collapsed;
masterSlider.ContrastSlider.Visibility = Visibility.Collapsed;
masterSlider.ContrastSliderText.Visibility = Visibility.Collapsed;
}
if (supportTemperature == 0)
{
masterSlider.TemperatureSliderLabel.Visibility = Visibility.Collapsed;
masterSlider.TemperatureSlider.Visibility = Visibility.Collapsed;
masterSlider.TemperatureSliderText.Visibility = Visibility.Collapsed;
}
}
private void ImportMonitorList(string path)
{
FileStream fs = new FileStream(path, FileMode.Open);
XmlSerializer xs = new XmlSerializer(typeof(MonitorManager));
this.monitorManager = (MonitorManager)xs.Deserialize(fs);
fs.Close();
}
protected void MainWindow_Loaded(object sender, RoutedEventArgs e)
{
monitorManager = new MonitorManager();
monitorManager.Initialize();
PluginsComboBox.DataContext = monitorManager.Plugins;
PluginsComboBox.DisplayMemberPath = "FriendlyName";
}
public void MonitorManager_CreateMonitor_Should_Get_An_Clean_Monitor_Back()
{
MonitorManager target = new MonitorManager();
target.Initialize();
Monitor actual;
actual = target.CreateMonitor("Test name", "http://laumania.net");
Assert.IsNotNull(actual);
}
public MainSettingPage()
{
InitializeComponent();
FirstMessage.Visibility = Visibility.Collapsed;
Btn_ChangeAllTimeOff.IsEnabled = true;
Btn_ChangeKioskMode.IsEnabled = true;
TP_TimeOut.SelectedTime = new TimeSpan(0, 0, 30);
TP_TimeAdvertising.SelectedTime = new TimeSpan(0, 0, 10);
MonitorManager m = new MonitorManager();
}
static void Main(string[] args)
{
List <DdcMonitorItem> result = MonitorManager.EnumerateMonitors().ToList();
foreach (var m in result)
{
m.UpdateBrightness();
Console.WriteLine(m);
//m.SetBrightness(40);
}
}
public void LoadFromConfig(MainWindow mainWindow)
{
// Auto
mainWindow.AutoCheckBox.IsChecked = config.GetBool(ConfigKeyAutoAdjust, false);
// Monitors
/* Disabled. Loading previous settings is useless
* Most likely, user will relaunch the app with different lightning condition at different time,
* so don't load Brightness/Contrast/Temperature settings from Config.
* User will adjust settings manually */
foreach (MonitorManager manager in MainWindow.MonitorManagers)
{
LoadMonitorSettingsInto(manager, manager.MasterMonitor);
foreach (Monitor monitor in manager.GetMonitorsList())
{
LoadMonitorSettingsInto(manager, monitor);
}
}
ConfigurationControl settingsWindow = mainWindow.ConfigurationControl;
// Monitor managers
MonitorManager monitorManager = GetMonitorManager();
MonitorManager = monitorManager;
if (monitorManager.GetType().Name == hardwareMonitorMgrName)
{
mainWindow.MonitorManagerTabControl.SelectedItem = mainWindow.MonitorManagerTabItemHardware;
}
if (monitorManager.GetType().Name == gammarampMonitorMgrName)
{
mainWindow.MonitorManagerTabControl.SelectedItem = mainWindow.MonitorManagerTabItemGammaRamp;
}
if (monitorManager.GetType().Name == wmiMonitorMgrName)
{
mainWindow.MonitorManagerTabControl.SelectedItem = mainWindow.MonitorManagerTabItemWmi;
}
if (monitorManager.GetType().Name == softwareMonitorMgrName)
{
mainWindow.MonitorManagerTabControl.SelectedItem = mainWindow.MonitorManagerTabItemSoftware;
}
// Data feed
settingsWindow.ThingSpeakAddressTextBox.Text = config.GetContent(ConfigKeyThingspeakAddress, ConfigKeyThingspeakAddressDefault);
settingsWindow.ThingSpeakChannelTextBox.Text = config.GetContent(ConfigKeyThingspeakChannel, ConfigKeyThingspeakChannelDefault);
settingsWindow.PlotFunction.Text = config.GetContent(ConfigKeyThingspeakLightFunction, ConfigKeyThingspeakLightFunctionDefault);
// Start with Windows
RegistryKey registryKey = Registry.CurrentUser.OpenSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", false);
settingsWindow.StartWithWindowsCheckbox.IsChecked = registryKey != null && registryKey.GetValue("SlimShady") != null;
}
public AppBarModel()
{
UpdateTime();
MonitorManager = new MonitorManager(App._computer);
foreach (MonitorConfig _config in Properties.Settings.Default.MonitorConfig.Where(c => c.Enabled).OrderBy(c => c.Order))
{
MonitorManager.AddPanel(_config);
}
MonitorManager.Update();
}
private void KeepOnLoad()
{
// Keep player and avatar objects
GameObject playerGO = GameObject.FindGameObjectWithTag("Player");
GameObject avatarGO = GameObject.FindGameObjectWithTag("Avatar");
if (playerGO == null || avatarGO == null)
{
MonitorManager.DisplayText("The user or avatar has not been loaded.");
throw new System.Exception("The player or avatar has not been loaded.");
}
DontDestroyOnLoad(playerGO);
DontDestroyOnLoad(avatarGO);
}
public void MonitorManager_SaveMonitors_Should_Save_A_Real_File()
{
//Arrange
MonitorManager target = new MonitorManager();
target.Initialize();
HelperMethods.FillMonitorList(target);
//Act
target.SaveMonitors();
//Assert
Assert.IsTrue(File.Exists("Monitors.xml"));
}
private void DisposeMonitors()
{
if (_monitorTimer != null)
{
_monitorTimer.Stop();
_monitorTimer = null;
}
if (MonitorManager != null)
{
MonitorManager.Dispose();
_monitorManager = null;
}
}
public void MonitorManager_CreateMonitor_Should_ComposeParts_So_Export_And_Imports_Are_Satisfied()
{
//Arrange
MonitorManager target = new MonitorManager();
Monitor monitor = null;
//Act
target.Initialize();
monitor = target.CreateMonitor("ComposeParts_Test", "http://laumania");
//Assert
Assert.IsTrue(monitor.Plugins != null);
Assert.IsTrue(monitor.Plugins.Count > 0);
}
public void MonitorManager_Add_Adds_One_Monitor_To_The_List()
{
//Arrange
MonitorManager target = new MonitorManager();
Monitor monitor = new Monitor();
//Act
target.Initialize();
target.Add(monitor);
//Assert
Assert.IsTrue(target.Monitors.Length == 1);
Assert.AreEqual(monitor, target.Monitors[0]);
}
public static List <Monitor> GenerateMonitorList(int amount)
{
List <Monitor> list = new List <Monitor>();
MonitorManager manager = new MonitorManager();
manager.Initialize();
for (int i = 0; i < amount; i++)
{
Monitor m = manager.CreateMonitor("Test_" + i, "http://laumania.net");
m.Name = "Test monitor no. " + i;
list.Add(m);
}
return(list);
}
public void Monitor_Ping_Should_Return_Error_On_Invalid_Url()
{
//Arrange
MonitorManager manager = new MonitorManager();
Monitor target = null;
MonitorPingResult result = null;
//Act
manager.Initialize();
target = manager.CreateMonitor("Test of invalid url monitor", "htassatp://[email protected]");
result = target.Ping();
//Assert
Assert.IsNotNull(result.Error);
Assert.IsFalse(result.Succeeded);
}
public void MonitorManager_PingMonitors_Should_Leave_Some_HistoryData()
{
//Arrange
int monitorAmount = 5;
MonitorManager manager = new MonitorManager();
List <Monitor> monitors = HelperMethods.GenerateMonitorList(monitorAmount);
//Act
manager.Initialize();
manager.AddMany(monitors);
manager.SaveMonitors();
manager.PingMonitors();
//Assert
Assert.IsTrue(File.Exists("Data/" + DateTime.Now.ToShortDateString() + ".xml")); //Bad check, come up with something else!
}
///GENMHASH:F886A4914B553C095A7AE17389D27E77:E5D5B4A8C36CFED5664896A53A66058D
internal MetricDefinitionImpl(MetricDefinitionInner innerModel, MonitorManager monitorManager)
: base(innerModel)
{
this.myManager = monitorManager;
this.inner = innerModel;
this.name = (inner.Name == null) ? null : new LocalizableStringImpl(inner.Name);
this.dimensions = null;
if (this.inner.Dimensions != null && this.inner.Dimensions.Any())
{
this.dimensions = new List <ILocalizableString>();
foreach (var lsi in inner.Dimensions)
{
this.dimensions.Add(new LocalizableStringImpl(lsi));
}
}
}
private void Btn_ChangeMonitor_Click(object sender, RoutedEventArgs e)
{
if (CB_Monit.SelectedIndex == 0)
{
App.Setting.NumberLeftMonitor = 1;
App.Setting.NumberRightMonitor = 0;
}
else
{
App.Setting.NumberLeftMonitor = 0;
App.Setting.NumberRightMonitor = 1;
}
MonitorManager.RestartPositionWindows();
App.Setting.Export();
}
public void MonitorManager_LoadMonitors_Should_Have_A_List_Larger_Than_Zero()
{
//Arrange
MonitorManager target = new MonitorManager();
target.Initialize();
HelperMethods.FillMonitorList(target);
target.SaveMonitors();
//Act
target.LoadMonitors();
//Assert
Assert.IsNotNull(target.Monitors);
Assert.IsTrue(target.Monitors[0].Plugins.Count > 0);
Assert.IsTrue(target.Monitors.Length > 0);
}
public void Monitor_Ping_Should_Return_PingResult_With_Out_Error()
{
//Arrange
MonitorManager manager = new MonitorManager();
Monitor target = null;
MonitorPingResult result = null;
//Act
manager.Initialize();
target = manager.CreateMonitor("Test of valid url monitor", "http://laumania.net");
result = target.Ping();
//Assert
Assert.IsNotNull(result);
Assert.IsNull(result.Error);
Assert.IsTrue(result.Succeeded);
}
public ProjectModel(string projectname)
{
ProjectName = projectname;
MainRoutine = new LadderDiagramViewModel("Main", this);
MainRoutine.IsMainLadder = true;
MMonitorManager = new MonitorManager(this);
MTVModel = new ModbusTableViewModel(this);
MMonitorManager.MMWindow.Manager = MMonitorManager;
PManager = new SerialPortManager();
UManager = new USBManager();
StreamReader sr = new StreamReader(
String.Format(@"{0:s}\simug\simuflib.c", FileHelper.AppRootPath));
FuncBlockViewModel libfuncblock = new FuncBlockViewModel(Properties.Resources.Library_Function, this);
libfuncblock.Code = sr.ReadToEnd();
libfuncblock.IsReadOnly = true;
LibFuncBlock = libfuncblock;
}
void Awake()
{
m_instance = this;
Type[] allTypes = typeof(IModel).Assembly.GetTypes();
for (int i = 0; i < allTypes.Length; ++i)
{
if (allTypes[i].IsSubclassOf(typeof(IModel)))
{
m_allModels.Add(Activator.CreateInstance(allTypes[i]) as IModel);
}
}
for (int i = 0; i < m_allModels.Count; ++i)
{
m_allModels[i].Init();
}
}
public MonitorHub(MonitorManager wm)
{
_manager = wm;
}
private void InitMonitors()
{
MonitorManager = new MonitorManager(Properties.Settings.Default.MonitorConfig);
MonitorManager.Update();
}
public void BindData(MonitorManager manager)
{
BindMonitors(manager.MonitorPanels);
ExpandConfig = true;
}
private void InitMonitors()
{
MonitorManager = new MonitorManager(Framework.Settings.Instance.MonitorConfig);
MonitorManager.Update();
}
public AcquisitionContext()
{
_managerSource = MonitorManager.SharedManager;
}
public AcquisitionContext(MonitorManager manager)
{
Contract.Requires(manager != null);
_managerSource = manager;
}
