public WeatherAnalysisViewModel()
{
this.selectedStations = new ObservableCollection <Station>();
this.availableStations = new ObservableCollection <Station>();
this.selectedStationsCollection = new CollectionViewSource();
selectedStationsCollection.Source = this.selectedStations;
selectedStationsCollection.Filter += FilterSelectedStations;
this.availableStationsCollection = new CollectionViewSource();
availableStationsCollection.Source = this.availableStations;
availableStationsCollection.Filter += FilterAvailableStations;
stationManager = ManagerLocator.GetStationManagerInstance;
addressManager = ManagerLocator.GetAddressManagerInstance;
measurementManager = ManagerLocator.GetMeasurementManagerInstance;
AddCommand = new RelayCommand(
ExecuteAddCommand,
CanExecuteAddCommand);
RemoveCommand = new RelayCommand(
ExecuteRemoveCommand,
CanExecuteRemoveCommand);
ApplyAnalysis = new RelayCommand(
ExecuteApplyAnalysis,
CanExecuteAnalysis
);
}
static bool Prefix(MFDVehicleOptions __instance)
{
Traverse mfdTraverse = new Traverse(__instance);
Debug.Log("measurements");
MeasurementManager measurements = (MeasurementManager)mfdTraverse.Field("measurements").GetValue();
Debug.Log("mfdPage");
object obj1 = mfdTraverse.Field("mfdPage").GetValue();
MFDPage mfdPage = null;
if (obj1 != null)
{
mfdPage = (MFDPage)obj1;
}
Debug.Log("portalPage");
object obj2 = mfdTraverse.Field("portalPage").GetValue();
MFDPortalPage portalPage = null;
if (obj2 != null)
{
portalPage = (MFDPortalPage)obj2;
}
Bananaspersecond.speedMode = (Bananaspersecond.speedMode + 1) % Bananaspersecond.units.measurementSpeedUnits.Count;
Bananaspersecond.UpdateDisplay(measurements, mfdPage, portalPage);
return(false);
}
public void TestGetQueryResultLatLon()
{
Mock <IMeasurementDao> dao = new Mock <IMeasurementDao>(MockBehavior.Strict);
Task <double[]> result = new Task <double[]>(() => new double[] { 2.3, 4.33 });
result.RunSynchronously();
dao.Setup(d => d.GetQueryResult(
It.IsAny <DateTime>(),
It.IsAny <DateTime>(),
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <List <Station> >(),
It.IsAny <decimal>(),
It.IsAny <decimal>(),
It.IsAny <int>()
)).Returns(result);
MeasurementManager m = new MeasurementManager(dao.Object, null, null);
double[] res = m.GetQueryResult(DateTime.Now, DateTime.Now, 0, 0, 0, null, 0, 0, 0).Result;
Assert.AreEqual(result.Result, res);
}
public static void AttachTargetToDepthMarker(GameObject currentFocusedObject, Handeness handenessDidNotClicked)
{
if (Instance.currentlyAttachedObj == currentFocusedObject)
{
return;
}
else if (Instance.currentlyAttachedObj != null)
{
DetachTargetFromDepthMarker();
}
if (currentFocusedObject != null && currentFocusedObject.tag.Equals("Target"))
{
Target target = currentFocusedObject.GetComponent <Target>();
if (target.State != TargetState.Drag)
{
DepthMarker.Instance.MoveDepthMarkerToFocus();
target.State = TargetState.Drag;
target.HandnessDidNotClick = handenessDidNotClicked;
Instance.currentlyAttachedObj = currentFocusedObject;
}
HandManager.CurrentHand.Vibrate(Thalmic.Myo.VibrationType.Short);
AudioManager.PlayCorrectSound();
target.StartTimeAttached = Time.time;
MeasurementManager.OnLeftClick(target);
}
}
public async Task <IEnumerable <Measurement> > GetLastMeasurementsForStation([FromUri] int queryMode, [FromUri] int stationId, [FromUri] int limit = 10)
{
try {
return(await MeasurementManager.GetLatestMeasurementsForStation(stationId, queryMode, limit));
}
catch {
throw new HttpResponseException(HttpStatusCode.NotFound);
}
}
public async Task <IEnumerable <Unit> > GetAllUnits()
{
try {
return(await MeasurementManager.GetAllUnits());
}
catch {
throw new HttpResponseException(HttpStatusCode.NotFound);
}
}
public async Task <IEnumerable <Measurement> > GetMeasurementsForStation([FromUri] string startDateTime, [FromUri] string endDateTime,
[FromUri] int queryMode, [FromUri] int stationId)
{
try {
return(await MeasurementManager.GetMeasurementsForStation(stationId, DateTime.Parse(startDateTime), DateTime.Parse(endDateTime), queryMode));
}
catch {
throw new HttpResponseException(HttpStatusCode.NotFound);
}
}
private void setMP()
{
string suffix = "";
if (paintType.getPaintType() != 3)
{
suffix = " paint";
}
measurementP.text = "Paint: " + MeasurementManager.getTotalPaintRequired().ToString("n3") + " litres of " + paintType.getName() + suffix;
}
public void TestGetDashboardRainValuesAsync()
{
Mock <IMeasurementDao> dao = new Mock <IMeasurementDao>(MockBehavior.Strict);
Task <double[]> result = new Task <double[]>(() => new double[] { 2.3, 4.33 });
result.RunSynchronously();
dao.Setup(d => d.GetDayAverageOfLastXDaysAsync(It.IsAny <int>(), It.IsAny <int>())).Returns(result);
MeasurementManager m = new MeasurementManager(dao.Object, null, null);
double[] res = m.GetDashboardRainValuesAsync().Result;
Assert.AreEqual(result.Result, res);
}
public void TestGetNumberOfMeasurementsOfWeekAsync()
{
Mock <IMeasurementDao> dao = new Mock <IMeasurementDao>(MockBehavior.Strict);
Task <long> result = new Task <long>(() => 100);
result.RunSynchronously();
dao.Setup(d => d.GetNumberOfMeasurementsFromTheLastXDaysAsync(It.IsAny <int>())).Returns(result);
MeasurementManager m = new MeasurementManager(dao.Object, null, null);
long res = m.GetNumberOfMeasurementsOfWeekAsync().Result;
Assert.AreEqual(result.Result, res);
}
//public float searchRange;
/* INHERITED FROM PLAYER */
// List<Unit> unitsOnMove
// List<Structure> playerStructures;
// int totalUnits;
// int totalGold;
// currentAction
new void Start()
{
base.Start();
this.pickedFirstAction = false;
this.listOfAttackingUnits = new List <Unit>(5);
this.typingPhase = 1;
this.defaultAttackFactor = 1.0;
this.numberOfStructuresOnMap = GameObject.FindGameObjectsWithTag("Structure").Length;
this.playerMeasurementsRef = GameObject.Find("MeasurementManager").GetComponent <MeasurementManager>();
this.wordManagerRef = GameObject.Find("WordManager").GetComponent <wordManager>();
InvokeRepeating("updateAITypingSpeed", 0, 5);
executeMainLoop();
}
void Start()
{
this.keysTypedDuringMeasurmentTime = 0;
this.lastPressedKeyTime = 0;
//this.keysPressedSinceLastMistake = 0;
this.isMeasuring = false;
this.wronglyPressedKeys = new List <char>(200);
this.enterUnitsMode = false;
this.lowerAvailableWordsBounds = 0;
this.upperAvailableWordsBounds = 0;
this.measurementManagerRef = getMeasurementManagerReference();
this.gameManager = getGameManagerReference();
this.infoToast = getToastManagerReference();
inputF.ActivateInputField();
}
private void OnStart()
{
if (MeasurementManager.CurrentExperiment == null)
{
var settings =
new ExperimentSettings(
TimeSpan.FromMilliseconds(ExperimentSettings.SamplingIntervalMilliseconds),
IsDeltaOnly);
MeasurementManager.CreateExperiment(settings);
}
else
{
MeasurementManager.CurrentExperiment.Settings.SamplingInterval = TimeSpan.FromMilliseconds(ExperimentSettings.SamplingIntervalMilliseconds);
}
MeasurementManager.Start();
}
public DashboardViewModel()
{
stationManager = ManagerLocator.GetStationManagerInstance;
measurementManager = ManagerLocator.GetMeasurementManagerInstance;
SeriesCollectionAverageTemperature = new SeriesCollection();
SeriesCollectionAverageRain = new SeriesCollection();
Labels = new ObservableCollection <string>();
YFormatter = value => value.ToString("");
SeriesCollectionAverageTemperature.Add(new LineSeries
{
Title = "Temperature",
LineSmoothness = 1,
Values = new ChartValues <double>()
});
SeriesCollectionAverageRain.Add(new LineSeries
{
Title = "Rain Amount",
LineSmoothness = 1,
Values = new ChartValues <double>()
});
Labels.Add(DateTime.Now.AddDays(-6).DayOfWeek.ToString());
Labels.Add(DateTime.Now.AddDays(-5).DayOfWeek.ToString());
Labels.Add(DateTime.Now.AddDays(-4).DayOfWeek.ToString());
Labels.Add(DateTime.Now.AddDays(-3).DayOfWeek.ToString());
Labels.Add(DateTime.Now.AddDays(-2).DayOfWeek.ToString());
Labels.Add(DateTime.Now.AddDays(-1).DayOfWeek.ToString());
Labels.Add(DateTime.Now.DayOfWeek.ToString());
StationCount = 0;
MeasurementCount = 0;
WeeklyMeasurementCount = 0;
StationClickCommand = new RelayCommand(
ExecuteStationClickCommand,
CanExecuteMeasurementClickCommand);
MeasurementClickCommand = new RelayCommand(
ExecuteMeasurementClickCommand,
CanExecuteMeasurementClickCommand);
}
private void AddMeasurment(Measurment measurement)
{
MeasurementManager.AddMeasurement(measurement);
var tempSeries = (LineSeries)PlotModel.Series[0];
var levelSeries = (LineSeries)PlotModel.Series[1];
tempSeries.Points.Add(new DataPoint(DateTimeAxis.ToDouble(measurement.DateTime), measurement.Temperature));
levelSeries.Points.Add(new DataPoint(DateTimeAxis.ToDouble(measurement.DateTime), measurement.Level));
if (Boiler.Template != null)
{
foreach (var key in Boiler.Template)
{
var series = (LineSeries)PlotModel.Series.First(x => x.Title == key);
series.Points.Add(new DataPoint(DateTimeAxis.ToDouble(measurement.DateTime), measurement.Values[key]));
}
}
PlotModel.InvalidatePlot(true);
}
public static void UpdateDisplay(MeasurementManager measurements, MFDPage mfdPage, MFDPortalPage portalPage)
{
string text = units.measurementAltUnits[altMode].name;
string text2 = units.measurementDistUnits[distMode].name;
string text3 = units.measurementSpeedUnits[speedMode].name;
if (mfdPage)
{
mfdPage.SetText("AltModeText", text);
mfdPage.SetText("DistModeText", text2);
mfdPage.SetText("SpeedModeText", text3);
return;
}
if (portalPage)
{
portalPage.SetText("AltModeText", text);
portalPage.SetText("DistModeText", text2);
portalPage.SetText("SpeedModeText", text3);
}
}
public void TestGetDashbardTemperaturesAsync()
{
Mock <IMeasurementDao> dao = new Mock <IMeasurementDao>(MockBehavior.Loose);
Mock <IStationDao> stat = new Mock <IStationDao>(MockBehavior.Loose);
Mock <IAddressManager> mgr = new Mock <IAddressManager>(MockBehavior.Loose);
Task <Station> statres = new Task <Station>(() => new Station());
stat.Setup(s => s.FindByIdAsync(It.IsAny <int>())).Returns(statres);
Task <double[]> result = new Task <double[]>(() => new double[] { 2.3, 4.33 });
result.RunSynchronously();
dao.Setup(d => d.GetDayAverageOfLastXDaysAsync(It.IsAny <int>(), It.IsAny <int>())).Returns(result);
MeasurementManager m = new MeasurementManager(dao.Object, stat.Object, mgr.Object);
double[] res = m.GetDashbardTemperaturesAsync().Result;
Assert.AreEqual(result.Result, res);
}
public async Task <IEnumerable <MeasurementAnalytic> > GetMeasurementsSum([FromUri] string startDateTime, [FromUri] string endDateTime,
[FromUri] int queryMode, [FromUri] int groupByMode, [FromUri] int?stationId = null)
{
try {
if (stationId == null)
{
return(await MeasurementManager.Sum(DateTime.Parse(startDateTime), DateTime.Parse(endDateTime), queryMode, groupByMode));
}
else
{
Station station = await StationManager.GetStationById(Convert.ToInt32(stationId));
IEnumerable <Station> stations = new List <Station> {
station
};
return(await MeasurementManager.Sum(DateTime.Parse(startDateTime), DateTime.Parse(endDateTime), queryMode, groupByMode, stations));
}
}
catch {
throw new HttpResponseException(HttpStatusCode.NotFound);
}
}
public void TestAddMeasurement()
{
Mock <IMeasurementDao> dao = new Mock <IMeasurementDao>(MockBehavior.Loose);
Task <bool> result = new Task <bool>(() => true);
result.RunSynchronously();
Measurement me = new Measurement()
{
MeasurementId = 3,
MeasurementTypeId = 3,
TimesStamp = DateTime.Now,
UnitId = 1,
Value = 3.4d,
StationId = 3,
};
dao.Setup(d => d.InsertAsync(It.IsAny <Measurement>())).Returns(result);
MeasurementManager m = new MeasurementManager(dao.Object, null, null);
var res = m.AddMeasurement(me).Result;
dao.Verify(d => d.InsertAsync(me), Times.Once);
}
public override Task OnLaunchAsync(Bundle savedInstanceState)
{
Platform.Init(this, savedInstanceState);
ExperimentalFeatures.Enable(ExperimentalFeatures.ShareFileRequest);
BoilerManager.Initialize();
MeasurementManager.Initialize();
Messenger.Default.Register <TitleMessage>(this, (message) => SupportActionBar.Title = message.Title);
Messenger.Default.Register <NotificationMessage>(this, (notification) =>
{
Toast
.MakeText(this, notification.Notification, ToastLength.Long)
.Show();
});
SetupDrawerView();
navigationService = NavigationService;
NavigationService.NavigateTo("Home");
return(Task.CompletedTask);
}
public void Store(PrimitiveType primitiveType)
{
MeasurementManager.OnStoreAction(this);
if (primitiveType == this.primitiveType)
{
//correct stored
// Time when stored
// Correct or Incorrect stored
// Information about the manipulation phase
Logger.LogStoreTarget(this, true);
TargetManager.DetachTargetFromDepthMarker(gameObject);
State = TargetState.Disabled;
gameObject.SetActive(false);
}
else
{
//incorrect stored
Logger.LogStoreTarget(this, false);
State = TargetState.Disabled;
TargetManager.DetachTargetFromDepthMarker(gameObject);
gameObject.SetActive(false);
}
gameObject.transform.position = Vector3.zero;
}
static bool Prefix(MeasurementManager __instance, ref string __result)
{
__result = Bananaspersecond.units.measurementSpeedUnits[Bananaspersecond.speedMode].label;
return(false);
}
static bool Prefix(MeasurementManager __instance, ref string __result, float speed)
{
__result = string.Format("{0:n0}", Bananaspersecond.ConvertedSpeed(speed));
return(false);
}
static bool Prefix(MeasurementManager __instance, ref string __result, float distance)
{
__result = string.Format("{0:n}{1}", Bananaspersecond.ConvertedDistance(distance), Bananaspersecond.units.measurementDistUnits[Bananaspersecond.distMode].label);
return(false);
}
static bool Prefix(MeasurementManager __instance, ref float __result, float speed)
{
__result = Bananaspersecond.ConvertedDistance(speed);
return(false);
}
static bool Prefix(MeasurementManager __instance, ref float __result, float altitude)
{
__result = Bananaspersecond.ConvertedAltitude(altitude);
return(false);
}
public MeasurementManagerTests()
{
_measurementManager = new MeasurementManager();
}
public void OnClick()
{
MeasurementManager.TrainingClick();
}
public void OnClick()
{
MeasurementManager.MeasurementClick();
}
private void OnStop()
{
MeasurementManager.Stop();
}
