public override bool Execute()
{
var changeAllMonitors = string.IsNullOrWhiteSpace(MonitorsNamesCollection);
var monitorRetriver = new GetMonitors(SyntheticsApiKey);
var monitorUpdater = new UpdateMonitor(SyntheticsApiKey);
Log.LogMessage("Starting API operations", MessageImportance.Low);
var monitorsCollection = changeAllMonitors ? monitorRetriver.GetAllMonitors() : GetNamedMonitors(monitorRetriver, MonitorsNamesCollection);
if (!monitorsCollection.Monitors.Any())
{
Log.LogMessage(MessageImportance.High, "Could not retrieve any monitors for given set of parameters");
return(false);
}
for (int counter = 0; counter < monitorsCollection.Count; counter++)
{
var monitor = monitorsCollection.Monitors[counter];
var monitorName = !string.IsNullOrWhiteSpace(monitor.Name) ? monitor.Name : "UNRETRIEVABLE";
Log.LogMessage(MessageImportance.Low, "Updating monitor '{0}' to status '{1}'", monitorName, GetTargetStatus(EnableMonitors));
var updateStatus = monitorUpdater.Execute(monitor, EnableMonitors);
if (!updateStatus)
{
//failure encountered during monitor update
Log.LogError("Could change monitor '{0}' to status '{1}'", monitorName, GetTargetStatus(EnableMonitors));
}
}
Log.LogMessage("Finished API operations", MessageImportance.Low);
return(true);
}
private async void Update_Clicked(object sender, RoutedEventArgs e)
{
var checkResult = await UpdateMonitor.CheckUpdate(force : true);
var progressIndicator = StatusBar.GetForCurrentView().ProgressIndicator;
switch (checkResult)
{
case UpdateMonitor.Result.Found:
IndicateUpdateAvailable();
break;
case UpdateMonitor.Result.NotFound:
progressIndicator.Text = App.Common.Services.Resources.LocalizedStringOf("MainProgressNoUpdate");
progressIndicator.ProgressValue = 0.0;
progressIndicator.ShowAsync();
await Task.Delay(3000);
progressIndicator.HideAsync();
break;
case UpdateMonitor.Result.NoAccess:
progressIndicator.Text = App.Common.Services.Resources.LocalizedStringOf("MainProgressNoInternet");
progressIndicator.ProgressValue = 0.0;
progressIndicator.ShowAsync();
await Task.Delay(3000);
progressIndicator.HideAsync();
break;
}
}
protected override async Task <DatabaseDownloadResult> StartAsync()
{
try
{
//ha kényszerített (első telepítés), akkor a rendelkezésre álló db-t töltöm be, egyébként letöltöm a szerverről
Stream fileStream;
int updatesVersion = CommonComponent.Current.Config.DBNumber;
bool downloadDisabled = !CommonComponent.Current.DatabaseExists || AppFields.ForceUpdate;
if (downloadDisabled)
{
fileStream = getResourceDatabase();
}
else
{
//updates.txt letöltése és mentése
updatesVersion = await getUpdatesVersion();
fileStream = await downloadDatabase(updatesVersion);
}
//Az adatbázis kicsomagolása, előtte a használt fájlokat lezárja
await decompressDatabase(fileStream);
fileStream.Dispose();
//Az adatbázis betöltése, az előző adatbázis alapján a backup elvégzése
await completeDatabase();
UpdateMonitor.UpdateDone(updatesVersion);
return(downloadDisabled ? DatabaseDownloadResult.Initialized : DatabaseDownloadResult.Success);
}
catch (WebException)
{
return(DatabaseDownloadResult.NoAccess);
}
}
private async void Update_Clicked(object sender, EventArgs e)
{
var checkResult = await UpdateMonitor.CheckUpdate(force : true);
switch (checkResult)
{
case UpdateMonitor.Result.Found:
IndicateUpdateAvailable();
break;
case UpdateMonitor.Result.NotFound:
ProgressIndicator prog = new ProgressIndicator {
Text = AppResources.MainProgressNoUpdate, IsVisible = true
};
SystemTray.SetProgressIndicator(this, prog);
await Task.Delay(3000);
SystemTray.SetProgressIndicator(this, null);
break;
case UpdateMonitor.Result.NoAccess:
ProgressIndicator prog1 = new ProgressIndicator {
Text = AppResources.MainProgressNoInternet, IsVisible = true
};
SystemTray.SetProgressIndicator(this, prog1);
await Task.Delay(3000);
SystemTray.SetProgressIndicator(this, null);
break;
}
}
private void ChangeMonitorsStatus(SyntheticsJsonRoot monitorsCollections, bool targetStatus)
{
var monitorUpdater = new UpdateMonitor(apiKey);
foreach (var monitor in monitorsCollections.Monitors)
{
monitorUpdater.Execute(monitor, targetStatus);
}
}
protected void UpdateFrame()
{
using (UpdateMonitor.BeginCollecting(PerformanceCollectionType.Update))
{
UpdateSubTree();
using (var buffer = DrawRoots.Get(UsageType.Write))
buffer.Object = GenerateDrawNodeSubtree(buffer.Index, ScreenSpaceDrawQuad.AABBf);
}
}
/// <summary>
/// Agent that runs a scheduled task
/// </summary>
/// <param name="task">
/// The invoked task
/// </param>
/// <remarks>
/// This method is called when a periodic or resource intensive task is invoked
/// </remarks>
protected async override void OnInvoke(ScheduledTask task)
{
try
{
Config.Initialize();
var services = new WPSilverlightCoreServices();
var tb = new TransitBase.TransitBaseComponent(
root: services.FileSystem.GetAppStorageRoot(),
directionsService: null,
preLoad: false,
bigTableLimit: Config.Current.BigTableLimit,
checkSameRoutes: Config.Current.CheckSameRoutes,
latitudeDegreeDistance: Config.Current.LatitudeDegreeDistance,
longitudeDegreeDistance: Config.Current.LongitudeDegreeDistance
);
var ub = new UserBase.UserBaseLinqToSQLComponent("Data Source=isostore:ddb.sdf", Config.Current.UBVersion, forbidMigration: true);
var common = new CommonComponent(services, tb, ub);
foreach (var tile in ShellTile.ActiveTiles)
{
if (tile.NavigationUri.OriginalString.StartsWith("/MainPage.xaml?tile="))
{
if (tile.NavigationUri.OriginalString.StartsWith("/MainPage.xaml?tile=stoproute"))
{
updateTileUnknown(tile);
}
else
{
Deployment.Current.Dispatcher.BeginInvoke(() =>
{
Tiles.UpdateTile(tile);
//bool ret = Tiles.UpdateTile(tile);
//if (ret == false)
// updateTileUnknown(tile);
tb.Flush();
});
}
}
}
if (NetworkInterface.NetworkInterfaceType == NetworkInterfaceType.Wireless80211 && NetworkInterface.GetIsNetworkAvailable() && !AppFields.UpdateAvailable)
{
var checkResult = await UpdateMonitor.CheckUpdate();
if (checkResult == UpdateMonitor.Result.Found)
{
ShellToast toast = new ShellToast();
toast.Title = "Update";
toast.Content = "A database update is required.";
toast.Show();
}
}
}
catch (Exception) { }
NotifyComplete();
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
if (e.NavigationMode == NavigationMode.New)
{
//adatbázis inicializálása első induláskor
if (!App.TB.DatabaseExists || AppFields.ForceUpdate)
{
await DatabaseDownloader.RunAsync();
}
ContentFrame.Navigate(typeof(DefaultPage));
//frissítés keresése
var checkUpdateResult = await UpdateMonitor.CheckUpdate();
if (checkUpdateResult == UpdateMonitor.Result.Found)
{
var dialog = new MessageDialog("A menetrend adatbázis elavult lehet.", "Frissítés elérhető");
dialog.Commands.Add(new UICommand {
Label = "Frissítés most", Id = true
});
dialog.Commands.Add(new UICommand {
Label = "Emlékeztessen később", Id = false
});
var res = await dialog.ShowAsync();
if ((bool)res.Id == true)
{
await DatabaseDownloader.RunAsync();
var finalDialog = new MessageDialog("A frissítés kész, kérem indítsa újra az alkalmazást.");
finalDialog.Commands.Add(new UICommand {
Label = "Rendben", Id = true
});
await finalDialog.ShowAsync();
throw new Exception("A frissítés kész, kérem indítsa újra az alkalmazást!");
}
}
//if (await ApplicationData.Current.LocalFolder.ContainsFileAsync("error.log"))
//{
// var logFile = await ApplicationData.Current.LocalFolder.GetFileAsync("error.log");
// string logData;
// using (var logStream = await logFile.OpenStreamForReadAsync())
// {
// logData = new StreamReader(logStream).ReadToEnd();
// }
// new MessageDialog(logData).ShowAsync();
// await logFile.DeleteAsync();
//}
}
}
// 로컬에서 데이터를 계속 보내주면 필요로 하는 데이터를 클라이언트에 보내준다.
public void Handle(UpdateMonitor localData)
{
// 로컬 데이터를 계속해서 받는다.
_localManager[localData.LocalData.LocalID].RealTimeLocalData =
localData.LocalData;
foreach (var obj in _localManager)
{
Context.Parent.Tell(new UpdateMonitor(obj.Value.RealTimeLocalData));
}
}
protected override async void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
if (e.NavigationMode == NavigationMode.New)
{
if (!App.AppEnabled)
{
MessageBox.Show("Your trial period has expired. You cannot use the app until you buy the full version.");
App.Current.Terminate();
}
//InitializerProcess.SendStatisctics();
if (!App.DatabaseExists() || AppFields.ForceUpdate)
{
var downloadResult = await DownloadDBDialog.Show();
DownloadDone(downloadResult);
}
if (InitializerProcess.FirstRun)
{
await ShowLocationConsentBox();
}
FavoritesTab.SetContent();
contentSetterTask = new PeriodicTask(updateContent);
contentSetterTask.RunEveryMinute();
string tile;
if (NavigationContext.QueryString.TryGetValue("tile", out tile) && !tile.StartsWith("stoproute"))
{
IRouteStopPair pair = App.UB.TileRegister.Get(Int32.Parse(tile));
if (pair != null)
{
NavigateToRouteStopPage(this, pair.Route, pair.Stop);
}
}
var checkUpdateResult = await UpdateMonitor.CheckUpdate();
if (checkUpdateResult == UpdateMonitor.Result.Found)
{
IndicateUpdateAvailable();
}
}
else
{
FavoritesTab.SetContent();
if (contentSetterTask != null)
{
contentSetterTask.Resume();
}
}
}
public void ChangeMonitorStatus()
{
var index = new Random().Next(this.monitorsCollection.Count - 1);
var monitor = this.monitorsCollection.Monitors[index];
var currentStatus = monitor.IsEnabled;
var monitorUpdater = new UpdateMonitor(this.apiKey);
//change monitor status to another
monitorUpdater.Execute(monitor, !currentStatus);
monitor = this.monitorRetriver.GetMonitorByName(monitor.Name);
Assert.IsFalse(currentStatus.Equals(monitor.IsEnabled));
//revert back
currentStatus = monitor.IsEnabled;
monitorUpdater.Execute(monitor, !currentStatus);
monitor = this.monitorRetriver.GetMonitorByName(monitor.Name);
Assert.IsFalse(currentStatus.Equals(monitor.IsEnabled));
}
// 해당 데이터를 클라이언트에게 보내준다.
public void SendToClient_DataOfLocal(UpdateMonitor localData)
{
int sendData = 0;
foreach (var client in _managerOfClients)
{
if (!client.Value.IsTerminated &&
client.Value.LocalIDMap.ContainsKey(localData.LocalData.LocalID))
{
// 해당 클라이언트의 viewType을 확인한다.
if (client.Value.ViewType == ChangedViewType.E_NONE_VIEW)
{
continue;
}
else if (client.Value.ViewType == ChangedViewType.E_CPU_VIEW)
{
sendData = localData.LocalData.CPUValue;
}
else if (client.Value.ViewType == ChangedViewType.E_MEMORY_VIEW)
{
sendData = localData.LocalData.MEMValue;
}
else if (client.Value.ViewType == ChangedViewType.E_DISK_VIEW)
{
sendData = localData.LocalData.DiskValue;
}
else if (client.Value.ViewType == ChangedViewType.E_NETWORK_VIEW)
{
sendData = localData.LocalData.NetworkValue;
}
else
{
sendData = localData.LocalData.TotalValue;
}
client.Value.AssignedClientActor.Tell
(new MessageOfSendLocalData()
{
AssignedLocalID = localData.LocalData.LocalID,
WaveData = sendData,
});
}
}
}
// 해당 데이터를 클라이언트에게 보내준다.
public void Handle(UpdateMonitor localData)
{
int sendData = 0;
for (int i = 0; i < _clientsCount; i++)
{
if (!_managerOfClients[i].IsTerminated &&
_managerOfClients[i].LocalIDMap.ContainsKey(localData.LocalData.LocalID))
{
if (_managerOfClients[i].LocalIDMap[localData.LocalData.LocalID])
{
// 해당 클라이언트의 viewType을 확인한다.
if (_managerOfClients[i].ViewType == ChangedViewType.E_NONE_VIEW)
{
continue;
}
else if (_managerOfClients[i].ViewType == ChangedViewType.E_CPU_VIEW)
{
sendData = localData.LocalData.CPUValue;
}
else if (_managerOfClients[i].ViewType == ChangedViewType.E_MEMORY_VIEW)
{
sendData = localData.LocalData.MEMValue;
}
else if (_managerOfClients[i].ViewType == ChangedViewType.E_DISK_VIEW)
{
sendData = localData.LocalData.DiskValue;
}
else if (_managerOfClients[i].ViewType == ChangedViewType.E_NETWORK_VIEW)
{
sendData = localData.LocalData.NetworkValue;
}
else
{
sendData = localData.LocalData.TotalValue;
}
_managerOfClients[i].AssignedClientActor.Tell(new MonitorUpdating(
localData.LocalData.LocalID, sendData));
}
}
}
}
public async void InitializePageState(object parameter)
{
if (!App.GetAppInfo().IsEnabled())
{
await new MessageDialog("Your trial period has expired. You cannot use the app until you buy the full version.").ShowAsync();
App.Current.Exit();
}
InitializerProcess.SendStatisctics();
Logging.Upload();
if (!App.TB.DatabaseExists || AppFields.ForceUpdate)
{
var downloadResult = await DownloadDBDialog.Show();
await DownloadDone(downloadResult, true);
}
if (InitializerProcess.FirstRun)
{
await ShowLocationConsentBox();
}
FavoritesPart.SetContent();
stateManager.ScheduleTaskEveryMinute(updateContent);
//if (App.SourceTileId != null)
//{
// NavigateToTile(App.SourceTileId.Value);
//}
var checkUpdateResult = await UpdateMonitor.CheckUpdate();
if (checkUpdateResult == UpdateMonitor.Result.Found)
{
IndicateUpdateAvailable();
}
//await Task.Delay(1000);
//Frame.Navigate(typeof(TestPage));
}
public override void Run()
{
while (!ExitRequested)
{
UpdateMonitor.NewFrame();
using (UpdateMonitor.BeginCollecting(PerformanceCollectionType.Scheduler))
{
UpdateScheduler.Update();
}
using (UpdateMonitor.BeginCollecting(PerformanceCollectionType.Update))
{
UpdateSubTree();
using (var buffer = DrawRoots.Get(UsageType.Write))
buffer.Object = GenerateDrawNodeSubtree(buffer.Object);
}
using (UpdateMonitor.BeginCollecting(PerformanceCollectionType.Sleep))
{
UpdateClock.ProcessFrame();
}
}
}
public void SendToClient_DataOfLocal(UpdateMonitor dataOfLocal)
{
Context.Child("ClientServer").Tell(dataOfLocal);
}
public void Handle(UpdateMonitor dataOfLocal)
{
Context.Child("ClientServer").Tell(dataOfLocal);
}
