public SearchHints(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//instaniate a filter controller so we can change the filter any time
var filter = new FilterController<string>();
//build a predicate when SeatchText changes
var filterApplier = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter)
.Subscribe(filter.Change);
//share the connection
var shared = tradeService.All.Connect().Publish();
//distinct list of customers
var customers = shared.DistinctValues(trade => trade.Customer);
//distinct list of currency pairs
var currencypairs = shared.DistinctValues(trade => trade.CurrencyPair);
//create single list of all customers all items in currency ypairs
var loader = customers.Or(currencypairs)
.Filter(filter) //filter strings
.Sort(SortExpressionComparer<string>.Ascending(str=>str))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _hints) //bind to hints list
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filter, shared.Connect(), filterApplier);
}
public IObservable<IChangeSet<Trade, long>> Query(Func<decimal> percentFromMarket)
{
if (percentFromMarket == null) throw new ArgumentNullException("percentFromMarket");
return Observable.Create<IChangeSet<Trade, long>>
(observer =>
{
var locker = new object();
var filter = new FilterController<Trade>();
filter.Change(trade =>
{
var near = percentFromMarket();
return Math.Abs(trade.PercentFromMarket) <= near;
});
//re-evaluate filter periodically
var reevaluator = Observable.Interval(TimeSpan.FromMilliseconds(250))
.Synchronize(locker)
.Subscribe(_ => filter.Reevaluate());
//filter on live trades matching % specified
var subscriber = _tradeService.All
.Connect(trade=>trade.Status==TradeStatus.Live)
.Synchronize(locker)
.Filter(filter)
.SubscribeSafe(observer);
return new CompositeDisposable(subscriber, filter, reevaluator);
});
}
public void DoNotThrowAWobblyWhenRemovingaMutatedValue()
{
var pageController = new PageController();
var sortController = new SortController<TestVm>(SortExpressionComparer<TestVm>.Ascending(t => t.DateFavorited ?? DateTime.MinValue));
var filterController = new FilterController<TestVm>(myVm => myVm.Id != 0);
var items = new ObservableCollectionExtended<TestVm>();
var itemCache = new SourceCache<TestVm, int>(myVm => myVm.Id);
var item1 = new TestVm(1) { DateFavorited = DateTime.Now };
var item2 = new TestVm(2) { DateFavorited = DateTime.Now };
itemCache.AddOrUpdate(item1);
itemCache.AddOrUpdate(item2);
bool error = false;
itemCache.Connect()
.Filter(filterController)
.Sort(sortController)
.Page(pageController)//error doesnt occur with paging disabled
.Bind(items)
.Subscribe(changes => { }, ex => error = true);
pageController.Change(new PageRequest(1, 100));
//NB: never errored if it was the first item which was removed
item2.DateFavorited = null;
itemCache.Remove(item2); //ERROR!
Assert.IsFalse(error, "Error has been thrown");
}
public LiveBikesViewModel(IRealTimeModel model)
{
var filter = new FilterController<StationDto>(t => true);
var filterApplier = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter)
.Subscribe(filter.Change);
var connect = model.All
.Connect()
.Filter(filter)
.Transform(t => t)
.ObserveOnDispatcher()
.Bind(_data)
.DisposeMany()
.Subscribe();
_cleanUp = new CompositeDisposable(connect, filterApplier);
}
public PagedDataViewer(ILogger logger, ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_logger = logger;
//watch for filter changes and change filter
var filterController = new FilterController<Trade>(trade => true);
var filterApplier = this.ObservePropertyValue(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(propargs => BuildFilter(propargs.Value))
.Subscribe(filterController.Change);
//watch for changes to sort and apply when necessary
var sortContoller = new SortController<TradeProxy>(SortExpressionComparer<TradeProxy>.Ascending(proxy=>proxy.Id));
var sortChange = SortParameters.ObservePropertyValue(t => t.SelectedItem).Select(prop=>prop.Value.Comparer)
.ObserveOn(schedulerProvider.TaskPool)
.Subscribe(sortContoller.Change);
//watch for page changes and change filter
var pageController = new PageController();
var currentPageChanged = PageParameters.ObservePropertyValue(p => p.CurrentPage).Select(prop => prop.Value);
var pageSizeChanged = PageParameters.ObservePropertyValue(p => p.PageSize).Select(prop => prop.Value);
var pageChanger = currentPageChanged.CombineLatest(pageSizeChanged,(page, size) => new PageRequest(page, size))
.DistinctUntilChanged()
.Sample(TimeSpan.FromMilliseconds(100))
.Subscribe(pageController.Change);
// filter, sort, page and bind to loaded data
var loader = tradeService.All .Connect()
.Filter(filterController) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(sortContoller, SortOptimisations.ComparesImmutableValuesOnly)
.Page(pageController)
.ObserveOn(schedulerProvider.MainThread)
.Do(changes => _pageParameters.Update(changes.Response))
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filterController, filterApplier, sortChange,sortContoller, pageChanger, pageController);
}
public void Get_RetrieveAllNutrientAgarPlates_ShouldReturnNamesAndStatusCode200()
{
// Arrange
var nutrientAgarPlatesVm = new List <NutrientAgarPlateViewModel>()
{
new NutrientAgarPlateViewModel()
{
Id = new Guid(),
Name = "Test nutrientAgarPlate 1"
},
new NutrientAgarPlateViewModel()
{
Id = new Guid(),
Name = "Test nutrientAgarPlate 1"
}
};
var serviceMock = new Mock <IAutocompleteService>();
serviceMock
.Setup(s => s.GetAllNutrientAgarPlates())
.Returns(nutrientAgarPlatesVm);
var loggerMock = new Mock <ILogger>();
var controller = new FilterController(serviceMock.Object, loggerMock.Object);
// Act
var response = controller.GetNutrientAgarPlates();
// Assert
Assert.NotNull(response);
Assert.IsType <OkObjectResult>(response);
var result = response as OkObjectResult;
var models = result.Value as List <NutrientAgarPlateViewModel>;
Assert.Equal(2, models.Count());
}
IEnumerator SetupBattle()
{
GameObject playerGO = Instantiate(player, playerPos);
playerUnit = playerGO.GetComponent <PlayerBattle>();
GameObject bossGO = Instantiate(boss, bossPos);
bossUnit = bossGO.GetComponent <FilterController>();
GameObject enemy1 = Instantiate(enemy, firstEnemyPos);
moldUnitOne = enemy1.GetComponent <MoldController>();
moldUnitOne.SetLevel(1);
GameObject enemy2 = Instantiate(enemy, secondEnemyPos);
moldUnitTwo = enemy2.GetComponent <MoldController>();
moldUnitTwo.SetLevel(1);
firstEnemyPos.GetChild(0).GetComponent <TextMeshProUGUI>().text = "LVL 1";
secondEnemyPos.GetChild(0).GetComponent <TextMeshProUGUI>().text = "LVL 1";
bossPos.GetChild(0).GetComponent <TextMeshProUGUI>().text = "You made a mistake crossing me...";
numEnemies = 2;
currEnemies = 2;
AdjustAttacks();
AdjustTargets();
PopulateItems();
StartCoroutine(PrintText("If you lose here, you will be lost for good..."));
yield return(new WaitForSeconds(10f));
state = BattleState.PLAYERTURN;
PlayerTurn();
}
public PagedDataViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//watch for filter changes and change filter
var filterController = new FilterController <Trade>(trade => true);
var filterApplier = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter)
.Subscribe(filterController.Change);
//watch for changes to sort and apply when necessary
var sortContoller = new SortController <TradeProxy>(SortExpressionComparer <TradeProxy> .Ascending(proxy => proxy.Id));
var sortChange = SortParameters.WhenValueChanged(t => t.SelectedItem).Select(prop => prop.Comparer)
.ObserveOn(schedulerProvider.TaskPool)
.Subscribe(sortContoller.Change);
//watch for page changes and change filter
var pageController = new PageController();
var currentPageChanged = PageParameters.WhenValueChanged(p => p.CurrentPage);
var pageSizeChanged = PageParameters.WhenValueChanged(p => p.PageSize);
var pageChanger = currentPageChanged.CombineLatest(pageSizeChanged, (page, size) => new PageRequest(page, size))
.DistinctUntilChanged()
.Sample(TimeSpan.FromMilliseconds(100))
.Subscribe(pageController.Change);
// filter, sort, page and bind to loaded data
var loader = tradeService.All.Connect()
.Filter(filterController) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(sortContoller, SortOptimisations.ComparesImmutableValuesOnly)
.Page(pageController)
.ObserveOn(schedulerProvider.MainThread)
.Do(changes => _pageParameters.Update(changes.Response))
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filterController, filterApplier, sortChange, sortContoller, pageChanger, pageController);
}
public void SetUp()
{
_mockApi = new Mock <ISearchAndCompareApi>();
_mockFlag = new Mock <IFeatureFlags>();
var mockGeocoder = new Mock <IGeocoder>();
_redirectUrlMock = new Mock <IRedirectUrlService>();
_filterController = new FilterController(_mockApi.Object, mockGeocoder.Object,
TelemetryClientHelper.GetMocked(),
new GoogleAnalyticsClient(null, null),
_redirectUrlMock.Object,
_mockFlag.Object)
{
TempData = new Mock <ITempDataDictionary>().Object
};
_resultsFilter = new ResultsFilter
{
funding = 2,
hasvacancies = true,
fulltime = true,
parttime = false,
};
}
public void Get_Owner_List_For_Filter()
{
var routes = new RouteCollection();
Console.WriteLine("Get Owner List For Filter.\n");
MRPEntities db = new MRPEntities();
HttpContext.Current = DataHelper.SetUserAndPermission();
FilterController objFilterController = new FilterController();
objFilterController.ControllerContext = new ControllerContext(MockHelpers.FakeUrlHelper.FakeHttpContext(), new RouteData(), objFilterController);
int PlanId = DataHelper.GetPlanId();
Sessions.PlanId = PlanId;
string UserId = Sessions.User.UserId.ToString();
string ActiveMenu = Enums.ActiveMenu.Home.ToString();
string viewBy = Enums.EntityType.Tactic.ToString();
var result = objFilterController.GetOwnerListForFilter(PlanId.ToString(), viewBy, ActiveMenu) as JsonResult;
Console.WriteLine(System.Reflection.MethodBase.GetCurrentMethod().Name + " \n The Assert Value: " + result);
Assert.IsNotNull(result);
}
public void Get_TacticType_List_For_Filter()
{
var routes = new RouteCollection();
Console.WriteLine("Get TacticType List For Filter.\n");
MRPEntities db = new MRPEntities();
HttpContext.Current = DataHelper.SetUserAndPermission();
FilterController objFilterController = new FilterController();
objFilterController.ControllerContext = new ControllerContext(MockHelpers.FakeUrlHelper.FakeHttpContext(), new RouteData(), objFilterController);
objFilterController.Url = MockHelpers.FakeUrlHelper.UrlHelper();
objFilterController.Url = new UrlHelper(new RequestContext(objFilterController.HttpContext, new RouteData()), routes);
int PlanId = DataHelper.GetPlanId();
Sessions.PlanId = PlanId;
var result = objFilterController.GetTacticTypeListForFilter(PlanId.ToString()) as JsonResult;
var serializedData = new RouteValueDictionary(result.Data);
var resultvalue = serializedData["isSuccess"];
Console.WriteLine(System.Reflection.MethodBase.GetCurrentMethod().Name + " \n The Assert Value resultvalue: " + resultvalue.ToString());
Assert.AreEqual("true", resultvalue.ToString(), true);
}
public void DoNotThrowAWobblyWhenRemovingaMutatedValue()
{
var pageController = new PageController();
var sortController = new SortController <TestVm>(SortExpressionComparer <TestVm> .Ascending(t => t.DateFavorited ?? DateTime.MinValue));
var filterController = new FilterController <TestVm>(myVm => myVm.Id != 0);
var items = new ObservableCollectionExtended <TestVm>();
var itemCache = new SourceCache <TestVm, int>(myVm => myVm.Id);
var item1 = new TestVm(1)
{
DateFavorited = DateTime.Now
};
var item2 = new TestVm(2)
{
DateFavorited = DateTime.Now
};
itemCache.AddOrUpdate(item1);
itemCache.AddOrUpdate(item2);
bool error = false;
itemCache.Connect()
.Filter(filterController)
.Sort(sortController)
.Page(pageController) //error doesnt occur with paging disabled
.Bind(items)
.Subscribe(changes => { }, ex => error = true);
pageController.Change(new PageRequest(1, 100));
//NB: never errored if it was the first item which was removed
item2.DateFavorited = null;
itemCache.Remove(item2); //ERROR!
error.Should().BeFalse();
}
public void SaveLastSetOfViews()
{
Console.WriteLine("To Save last set data.\n");
MRPEntities db = new MRPEntities();
HttpContext.Current = DataHelper.SetUserAndPermission();
FilterController objFilterController = new FilterController();
string CommaSeparatedPlanId = DataHelper.GetPlanId().ToString();
string ViewBy = PlanGanttTypes.Tactic.ToString();
List <int> lstPlanids = CommaSeparatedPlanId.Split(',').ToList().Select(id => Convert.ToInt32(id)).ToList();
List <int> tactic = db.Plan_Campaign_Program_Tactic.Where(id => lstPlanids.Contains(id.Plan_Campaign_Program.Plan_Campaign.PlanId)).Select(tactictype => tactictype.TacticTypeId).ToList();
string tactictypeids = string.Join(",", tactic);
List <int> Owner = db.Plans.Where(id => lstPlanids.Contains(id.PlanId)).Select(plan => plan.CreatedBy).ToList();
string Ownerids = string.Join(",", Owner);
var UserID = Sessions.User.ID;
string CommaSeparatedCustomFields = DataHelper.GetSearchFilterForCustomRestriction(UserID);
List <string> lststatus = new List <string>();
lststatus.Add(Enums.TacticStatusValues[Enums.TacticStatus.Created.ToString()].ToString());
lststatus.Add(Enums.TacticStatusValues[Enums.TacticStatus.Submitted.ToString()].ToString());
lststatus.Add(Enums.TacticStatusValues[Enums.TacticStatus.InProgress.ToString()].ToString());
lststatus.Add(Enums.TacticStatusValues[Enums.TacticStatus.Approved.ToString()].ToString());
lststatus.Add(Enums.TacticStatusValues[Enums.TacticStatus.Complete.ToString()].ToString());
lststatus.Add(Enums.TacticStatusValues[Enums.TacticStatus.Decline.ToString()].ToString());
string Status = string.Join(",", lststatus);
var result = objFilterController.SaveLastSetofViews(CommaSeparatedPlanId, CommaSeparatedCustomFields, Ownerids, tactictypeids, Status, "", "", "") as JsonResult;
Console.WriteLine(System.Reflection.MethodBase.GetCurrentMethod().Name + " \n The Assert Value result.Data: " + result.Data);
Assert.IsNotNull(result.Data);
}
public LiveTradesViewer(ILogger logger,ITradeService tradeService,SearchHints searchHints)
{
_logger = logger;
_searchHints = searchHints;
var filter = new FilterController<Trade>(trade=>true);
var filterApplier = SearchHints.ObservePropertyValue(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(propargs=>BuildFilter(propargs.Value))
.Subscribe(filter.Change);
var loader = tradeService.All
.Connect(trade => trade.Status == TradeStatus.Live) //prefilter live trades only
.Filter(filter) // apply user filter
//if using dotnet 4.5 can parallelise 'case it's quicler
.Transform(trade => new TradeProxy(trade),new ParallelisationOptions(ParallelType.Ordered,5))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp),SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filter, filterApplier, searchHints);
}
public LiveTradesViewer(ILogger logger, ITradeService tradeService, SearchHints searchHints)
{
_logger = logger;
_searchHints = searchHints;
var filter = new FilterController <Trade>(trade => true);
var filterApplier = SearchHints.ObservePropertyValue(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(propargs => BuildFilter(propargs.Value))
.Subscribe(filter.Change);
var loader = tradeService.All
.Connect(trade => trade.Status == TradeStatus.Live) //prefilter live trades only
.Filter(filter) // apply user filter
//if using dotnet 4.5 can parallelise 'case it's quicler
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOnDispatcher()
.Bind(_data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filter, filterApplier, searchHints);
}
public async Task Get_ReturnsJson_ListofImages(string type, int start, int count, int expectedStatus)
{
// create image
var img = MockHelpers.CreateImage(DateTime.Now.ToShortDateString(), "Caption 1", "location 1");
// create a new user
var pkUser = await MockHelpers.CreateNewUser(1, Guid.NewGuid().ToString(), "*****@*****.**", "Password@123", _fixture);
// get user manager
var _userManager = MockHelpers.CreateMockUserManager(pkUser);
var user = new ClaimsPrincipal(new ClaimsIdentity(new List <Claim>
{
new Claim(ClaimTypes.NameIdentifier, pkUser.Id)//,
//new Claim(ClaimTypes.Name, pkUser.UserName),
// new Claim(ClaimTypes.Email, pkUser.Email),
//new Claim(ClaimTypes.Role, "Admin")
}));
// upload image
var imgCont = new ImageController(_webHostEnvironment.Object, _configurationManager.Object, _userManager, _fixture.Context, _imapper);
imgCont.ControllerContext = new ControllerContext()
{
HttpContext = new DefaultHttpContext()
{
User = user
}
};
ActionResult upRes = await imgCont.UploadImage(img);
// check uploaded images are there
var filtContr = new FilterController(_fixture.Context, _imapper);
ObjectResult response;
if (type == "artistId")
{
response = await filtContr.Images(type, start, count, pkUser.Id) as ObjectResult;
}
else
{
response = await filtContr.Images(type, start, count) as ObjectResult;
}
Assert.Equal(expectedStatus, response.StatusCode);
if (expectedStatus != StatusCodes.Status200OK)
{
return;
}
//var okResult = Assert.IsType<OkObjectResult>(response);
if (type == "pikcha100")
{
var imlst = response.Value as List <PikchaImageFilterDTO>;
// validate uploaded image
Assert.True(imlst.Exists(i => i.Title == img.Title));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + imlst[0].Thumbnail));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + imlst[0].Watermark));
return;
}
var lst = response.Value as List <PikchaImageFilterDTO>;
// validate uploaded image
Assert.True(lst.Exists(i => i.Title == img.Title));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + lst[0].Thumbnail));
Assert.True(File.Exists(PikchaConstants.PIKCHA_IMAGE_UPLOAD_ROOT_FOLDER + lst[0].Watermark));
}
/// <summary>
/// Creates a stream using the specified controlled filter.
/// The controlled filter enables dynamic inline changing of the filter.
/// </summary>
/// <typeparam name="TObject">The type of the object.</typeparam>
/// <typeparam name="TKey">The type of the key.</typeparam>
/// <param name="source">The source.</param>
/// <param name="filterController">The controlled filter.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">filterController</exception>
public static IObservable <IChangeSet <TObject, TKey> > Connect <TObject, TKey>(this IObservableCache <TObject, TKey> source, FilterController <TObject> filterController)
{
if (filterController == null)
{
throw new ArgumentNullException(nameof(filterController));
}
return(source.Connect().Filter(filterController));
}
private void FilterDelete()
{
int FilterId = -1;
if (Params.ContainsKey("FilterId"))
{
FilterId = Convert.ToInt32(Params["FilterId"]);
}
if (FilterId == -1)
{
return;
}
FilterController fc = new FilterController();
fc.Filter_Delete(PortalId, ModuleId, FilterId);
}
private string FilterGet()
{
int FilterId = -1;
if (Params.ContainsKey("FilterId"))
{
FilterId = Convert.ToInt32(Params["FilterId"]);
}
FilterController fc = new FilterController();
FilterInfo filter = fc.Filter_Get(PortalId, ModuleId, FilterId);
string sOut = "{";
sOut += Utilities.JSON.Pair("FilterId", filter.FilterId.ToString());
sOut += ",";
sOut += Utilities.JSON.Pair("FilterType", filter.FilterType.ToString());
sOut += ",";
sOut += Utilities.JSON.Pair("Find", HttpUtility.UrlEncode(filter.Find.Replace(" ", "-|-")));
sOut += ",";
sOut += Utilities.JSON.Pair("Replacement", HttpUtility.UrlEncode(filter.Replace.Replace(" ", "-|-")));
sOut += "}";
return sOut;
}
public void Initialise()
{
_source = new SourceCache<Person, string>(p=>p.Key);
_filter = new FilterController<Person>(p=>p.Age>20);
_results = new ChangeSetAggregator<Person, string>(_source.Connect(_filter));
}
public static FilterController Fixture()
{
FilterController controller = new FilterController(new FilterRepository(), "", new LoginView());
return(controller);
}
public void ViewObservationsForLoggedInUser()
{
using (ShimsContext.Create())
{
//Login user
LoginTestUserAnalyser();
ShimFilePath();
// Add another role to user context
base.AddSightingRoleToUserContext();
UserRoleModel roleModel = new UserRoleModel();
IRole newAnalyzerRole = SessionHandler.UserContext.CurrentRoles[0];
AccountController.ChangeUserRole(Convert.ToString(newAnalyzerRole.Id), roleModel);
// Verify role
Assert.IsTrue(SessionHandler.UserContext.CurrentRole.Id == newAnalyzerRole.Id);
// Set language to swedish since reference data is on that language
SetSwedishLanguage();
// Create controllers
FilterController filterController = new FilterController();
ResultController resultController = new ResultController();
StubResultController(resultController);
MySettingsController settingsController = new MySettingsController();
// TODO Add tests for presentation controller data
FormatController presentationController = new FormatController();
//Check that no data is set to mysettings, except for map and table that should be checked by default
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count == 0);
Assert.IsTrue(SessionHandler.MySettings.Presentation.Map.IsActive);
Assert.IsTrue(SessionHandler.MySettings.Presentation.Table.IsActive);
Assert.IsFalse(SessionHandler.MySettings.Filter.Taxa.IsActive);
//********************************* Set and test filter data ***************************
//Select to filter on taxa and select taxa ids
//SessionHandler.MySettings.Filter.TaxaSetting.IsSelected = true;
filterController.RemoveAllFilteredTaxon("Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count == 0);
//Use taxon 100573-Griffelblomfluga
int[] taxaIds = new int[] { 100573 };
string strJson = JsonConvert.SerializeObject(taxaIds);
filterController.AddTaxaToFilter(strJson, "Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(100573));
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count == 1);
//**************************** Set spatial data ***************************************************
Polygon polygon1 = CreateTestPolygon1();
var feature1 = new Feature(polygon1);
var features = new List <Feature> {
feature1
};
var featureCollection = new FeatureCollection(features);
string geojson = JsonConvert.SerializeObject(featureCollection, JsonHelper.GetDefaultJsonSerializerSettings());
// Update spatial filter
JsonNetResult filterResult = filterController.UpdateSpatialFilter(geojson);
JsonModel jsonFilterResult = (JsonModel)filterResult.Data;
Assert.IsTrue(jsonFilterResult.Success);
Assert.IsTrue(SessionHandler.MySettings.Filter.Spatial.IsActive == true);
Assert.IsTrue(SessionHandler.MySettings.Filter.Spatial.Polygons.Count == 1);
//**************************** Check map data *******************************************************
// Sow map view for Griffelblomfluga
int numberOfObservations = 0;
ViewResult result = resultController.SpeciesObservationMap();
Assert.IsNotNull(result);
//Get the map data to be shown
JsonNetResult obsMap = resultController.GetObservationsAsGeoJSON();
Assert.IsNotNull(obsMap.Data);
var jsonMapResult = (JsonModel)obsMap.Data;
var noObs = (SpeciesObservationsGeoJsonModel)jsonMapResult.Data;
numberOfObservations = noObs.Points.Features.Count;
Assert.IsTrue(SessionHandler.MySettings.Presentation.Map.IsActive);
Assert.IsTrue(SessionHandler.MySettings.Presentation.Table.IsActive);
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.IsActive);
//************************ Check table data *********************************************
//Select to show table data from observations
result = resultController.SpeciesObservationTable() as ViewResult;
Assert.IsNotNull(result);
var viewModel = result.ViewData.Model as ViewTableViewModel;
Assert.IsNotNull(viewModel);
//Get observations
var obsResult = resultController.GetPagedObservationListAsJSON(1, 0, 25);
Assert.IsNotNull(obsResult);
JsonModel jsonResult = (JsonModel)obsResult.Data;
List <Dictionary <string, string> > observationListResult = (List <Dictionary <string, string> >)jsonResult.Data;
//Check observations
Assert.IsNotNull(jsonResult);
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total > 5);
Assert.IsTrue(observationListResult.Count > 5);
Assert.IsTrue(numberOfObservations == observationListResult.Count, "Number of observations differs between Map and ObsTable");
//Verfy observations
BaseDataTest.VerifyObservationDataForGriffelblomfluga1000573(observationListResult);
//*********************** Check detailsPanel ****************************************************
string observationGUID = observationListResult[5]["ObservationId"];
DetailsController detailsController = new DetailsController();
//Act
// Returning "hard coded" value för first observation for griffelblomfluga
var detailsResult = detailsController.ObservationDetail(observationGUID) as ViewResult;
//Assert
Assert.IsNotNull(detailsResult);
//*********************** Verfy user settings, save and load *************************************
// Save settings
settingsController.SaveMySettings("Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count > 0);
//Logout TestUser
LogoutTestUser();
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count == 0);
Assert.IsTrue(SessionHandler.MySettings.Presentation.Map.IsActive);
Assert.IsTrue(SessionHandler.MySettings.Presentation.Table.IsActive);
Assert.IsFalse(SessionHandler.MySettings.Filter.Taxa.IsActive);
LoginTestUserAnalyser();
//Use taxon 100573-Griffelblomfluga
taxaIds = new int[] { 100573 };
strJson = JsonConvert.SerializeObject(taxaIds);
filterController.AddTaxaToFilter(strJson, "Home/Index");
result = resultController.SpeciesObservationTable() as ViewResult;
Assert.IsNotNull(result);
// Check observations in table
obsResult = resultController.GetPagedObservationListAsJSON(1, 0, 25);
Assert.IsNotNull(obsResult);
jsonResult = (JsonModel)obsResult.Data;
observationListResult = (List <Dictionary <string, string> >)jsonResult.Data;
Assert.IsNotNull(jsonResult);
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total > 5);
Assert.IsTrue(observationListResult.Count > 5);
Assert.IsTrue(numberOfObservations == observationListResult.Count, "Number of observations differs between saved settings and not saved settings for ObsTable");
BaseDataTest.VerifyObservationDataForGriffelblomfluga1000573(observationListResult);
// Reset to english language
SetEnglishLanguage();
}
}
public void GetMatchingTaxaTest()
{
using (ShimsContext.Create())
{
FilterController filterController;
JsonNetResult result;
JsonModel jsonResult;
List <TaxonViewModel> taxaListResult;
String strClipboard;
// Test get data using RowDelimiter.ReturnLinefeed
filterController = new FilterController();
strClipboard = "1" + Environment.NewLine + "2" + Environment.NewLine + "4";
result = filterController.GetMatchingTaxa(strClipboard, RowDelimiter.ReturnLinefeed);
jsonResult = (JsonModel)result.Data;
taxaListResult = (List <TaxonViewModel>)jsonResult.Data;
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total == 3);
Assert.IsTrue(taxaListResult.Count == 3);
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 1));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 2));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 4));
// Test get data using RowDelimiter.Semicolon
strClipboard = "1;2;4";
result = filterController.GetMatchingTaxa(strClipboard, RowDelimiter.Semicolon);
jsonResult = (JsonModel)result.Data;
taxaListResult = (List <TaxonViewModel>)jsonResult.Data;
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total == 3);
Assert.IsTrue(taxaListResult.Count == 3);
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 1));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 2));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 4));
// Test get data using RowDelimiter.Tab
strClipboard = "1\t2\t4";
result = filterController.GetMatchingTaxa(strClipboard, RowDelimiter.Tab);
jsonResult = (JsonModel)result.Data;
taxaListResult = (List <TaxonViewModel>)jsonResult.Data;
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total == 3);
Assert.IsTrue(taxaListResult.Count == 3);
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 1));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 2));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 4));
// Test get data using RowDelimiter.Tab
strClipboard = "1|2|4";
result = filterController.GetMatchingTaxa(strClipboard, RowDelimiter.VerticalBar);
jsonResult = (JsonModel)result.Data;
taxaListResult = (List <TaxonViewModel>)jsonResult.Data;
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total == 3);
Assert.IsTrue(taxaListResult.Count == 3);
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 1));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 2));
Assert.IsTrue(taxaListResult.Any(x => x.TaxonId == 4));
// Test get taxon with invalid taxon ids
filterController = new FilterController();
strClipboard = "47894789473849784937849;323343443344;-342342";
result = filterController.GetMatchingTaxa(strClipboard, RowDelimiter.Semicolon);
jsonResult = (JsonModel)result.Data;
taxaListResult = (List <TaxonViewModel>)jsonResult.Data;
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total == 0);
Assert.IsTrue(taxaListResult.Count == 0);
}
}
public static PursuitGainCalculations CountSingleTypeSignalPursuitParameters(SpotGazeFileData fileData, FiltersConfig filterConfig)
{
var mincal = fileData.Spot.Min();
var maxcal = fileData.Spot.Max();
var amp = (maxcal - mincal) / 2;
var srod = (maxcal + mincal) / 2;
var maxIndex = fileData.Spot.ToList().IndexOf(maxcal);
var minIndex = fileData.Spot.ToList().IndexOf(mincal);
var sinLenght = Convert.ToDouble(Math.Abs(maxIndex - minIndex));
var kspIndexes = new List <int>();
var accuracyKspDiffValues = new List <double>();
var accuracyKspSpotValues = new List <double>();
for (int i = 0; i < fileData.Spot.Length; i++)
{
var xSpot = fileData.Spot[i];
if (Math.Abs(xSpot - srod) > amp * 0.995D)
{
kspIndexes.Add(i);
//Accuracy
var xEye = fileData.Eye[i];
var diffVal = Math.Abs(xEye - xSpot);
accuracyKspDiffValues.Add(diffVal);
accuracyKspSpotValues.Add(Math.Abs(xSpot));
}
}
var kspEyeValues = new List <double>();
var kspSpotValues = new List <double>();
var results = new List <double>();
var filteredControlWindows = new List <Dictionary <double, double> >();
var kspDiffValues = new List <Dictionary <double, double> >();
//fix first sin
var kspStartIndex = 0;
for (int i = 0; i < kspIndexes.Count - 1; i++)
{
var result = kspIndexes[i + 1] - kspIndexes[i];
if (result > 30)
{
kspStartIndex = i;
break;
}
}
//fix last sin
var kspEndIndex = kspIndexes.Count;
for (int y = kspIndexes.Count; y-- > 1;)
{
var endRsult = kspIndexes[y] - kspIndexes[y - 1];
if (endRsult > 20)
{
kspEndIndex = y;
break;
}
}
kspIndexes = kspIndexes.Skip(kspStartIndex + 1).Take(kspEndIndex - kspStartIndex - 1).ToList();
for (int j = 0; j < kspIndexes.Count; j++)
{
var index = kspIndexes[j];
var controlWindow = new List <double>();
var controlTimeDeltas = new List <double>();
var controlWindowLength = Convert.ToInt32(Math.Round(sinLenght / 5, 0));
if (j > 0)
{
controlWindow = fileData.Eye.Skip(index - (controlWindowLength / 2)).Take(controlWindowLength).ToList();
controlTimeDeltas = fileData.TimeDeltas.Skip(index - (controlWindowLength / 2)).Take(controlWindowLength).ToList();
}
else
{
controlWindow = fileData.Eye.Skip(index).Take(controlWindowLength).ToList();
controlTimeDeltas = fileData.TimeDeltas.Skip(index).Take(controlWindowLength).ToList();
}
if (filterConfig.FilterByButterworth)
{
controlWindow = FilterController.FilterByButterworth(filterConfig, controlWindow.ToArray()).ToList();
}
var filteredWindowItems = new Dictionary <double, double>();
for (int g = 0; g < controlWindow.Count(); g++)
{
filteredWindowItems.Add(controlTimeDeltas[g], controlWindow[g]);
}
filteredControlWindows.Add(filteredWindowItems);
double eyeValue = controlWindow.Average();
var spotValue = fileData.Spot[index];
var result = eyeValue / spotValue;
results.Add(result);
}
var gainCalculations = new Dictionary <string, double?>();
var longSinGain = results.Average();
gainCalculations.Add("Long", longSinGain);
var longSinW1 = accuracyKspDiffValues.Sum();
var longSinW2 = accuracyKspSpotValues.Sum();
var longSinAcc = 1D - (longSinW1 / longSinW2);
var accuracyCalculations = new Dictionary <string, double?>();
accuracyCalculations.Add("Long", longSinAcc);
return(new PursuitGainCalculations
{
Gains = gainCalculations,
Accuracies = accuracyCalculations,
FilteredControlWindows = filteredControlWindows
});
}
public static PursuitGainCalculations CountCompoundSignalPursuitParameters(SpotGazeFileData fileData, FiltersConfig filterConfig)
{
var mncal = fileData.Spot.Min();
var mxcal = fileData.Spot.Max();
var amp = (mxcal - mncal) / 2;
var srod = (mxcal + mncal) / 2;
var start = fileData.Eye.FirstOrDefault(x => x == srod);
var testValues = new List <double>();
var kspIndexes = new List <KeyValuePair <double, int> >();
var accuracyKspSpotValues = new List <KeyValuePair <double, double> >();
var accuracyKspDiffValues = new List <KeyValuePair <double, double> >();
double sinLongStart;
double sinMidStart;
double sinShortStart;
double sinLongEnd;
double sinMidEnd;
double sinShortEnd;
if (fileData.FileType == FileType.Maruniec)
{
// maruniec do zrobienia
sinMidStart = 37 * Consts.TimeScaleFactorStandard;
sinShortStart = 79 * Consts.TimeScaleFactorStandard;
}
else
{
sinLongStart = 12 * Consts.TimeScaleFactorStandard;
sinLongEnd = 32 * Consts.TimeScaleFactorStandard;
sinMidStart = 40 * Consts.TimeScaleFactorStandard;
sinMidEnd = 68 * Consts.TimeScaleFactorStandard;
sinShortStart = 77 * Consts.TimeScaleFactorStandard;
sinShortEnd = 90 * Consts.TimeScaleFactorStandard;
}
var unifiedTimeStamps = InputDataHelper.GetTimeStampsScaled(fileData.Time, fileData.FileType);
for (int i = 0; i < fileData.Spot.Length; i++)
{
var xSpot = fileData.Spot[i];
var sinLenght = 240D;
if (unifiedTimeStamps[i] >= sinMidStart && unifiedTimeStamps[i] <= sinShortStart)
{
sinLenght = 120D;
}
else if (unifiedTimeStamps[i] >= sinShortStart)
{
sinLenght = 30D;
}
if (Math.Abs(xSpot - srod) > amp * 0.995D)
{
kspIndexes.Add(new KeyValuePair <double, int>(sinLenght, i));
//Accuracy
var xEye = fileData.Eye[i];
var diffVal = Math.Abs(xEye - xSpot);
accuracyKspDiffValues.Add(new KeyValuePair <double, double>(sinLenght, diffVal));
accuracyKspSpotValues.Add(new KeyValuePair <double, double>(sinLenght, Math.Abs(xSpot)));
}
}
var kspEyeValues = new List <double>();
var kspSpotValues = new List <double>();
var results = new List <KeyValuePair <double, double> >();
var isPositive = true;
var times = new List <double>();
var filteredControlWindows = new List <Dictionary <double, double> >();
var kspDiffValues = new List <Dictionary <double, double> >();
for (int j = 0; j < kspIndexes.Count; j++)
{
var sinLenght = kspIndexes[j].Key;
var index = kspIndexes[j].Value;
var time = InputDataHelper.GetScaledTimeFromIndex(fileData, index).GetValueOrDefault();
times.Add(time);
var controlWindow = new List <double>();
var controlTimeDeltas = new List <double>();
var controlWindowLength = Convert.ToInt32(Math.Round(sinLenght / 5, 0));
if (j > 0)
{
controlWindow = fileData.Eye.Skip(index - (controlWindowLength / 2)).Take(controlWindowLength).ToList();
controlTimeDeltas = fileData.TimeDeltas.Skip(index - (controlWindowLength / 2)).Take(controlWindowLength).ToList();
}
else
{
controlWindow = fileData.Eye.Skip(index).Take(controlWindowLength).ToList();
controlTimeDeltas = fileData.TimeDeltas.Skip(index).Take(controlWindowLength).ToList();
}
if (filterConfig.FilterByButterworth)
{
controlWindow = FilterController.FilterByButterworth(filterConfig, controlWindow.ToArray()).ToList();
}
var filteredWindowItems = new Dictionary <double, double>();
for (int g = 0; g < controlWindow.Count(); g++)
{
filteredWindowItems.Add(controlTimeDeltas[g], controlWindow[g]);
}
filteredControlWindows.Add(filteredWindowItems);
double eyeValue;
if (isPositive)
{
eyeValue = controlWindow.Average(); //Max();
isPositive = false;
}
else
{
eyeValue = controlWindow.Average(); //Min();
isPositive = true;
}
if (sinLenght == 30D)
{
testValues.Add(eyeValue);
}
//var eyeValue = fileData.Eye[index];
var spotValue = fileData.Spot[index];
var result = eyeValue / spotValue;
results.Add(new KeyValuePair <double, double>(sinLenght, result));
}
var longSinGain = new double?();
if (results.Where(x => x.Key == 240D).Count() > 0)
{
longSinGain = results.Where(x => x.Key == 240D).Select(x => x.Value).Average();
}
var midSinGain = new double?();
if (results.Where(x => x.Key == 120D).Select(x => x.Value).Count() > 0)
{
midSinGain = results.Where(x => x.Key == 120D).Select(x => x.Value).Average();
}
var shortSinGain = new double?();
if (results.Where(x => x.Key == 30D).Select(x => x.Value).Count() > 0)
{
shortSinGain = results.Where(x => x.Key == 30D).Select(x => x.Value).Average();
}
var gainCalculations = new Dictionary <string, double?>();
if (longSinGain.HasValue)
{
gainCalculations.Add("Long", longSinGain.GetValueOrDefault());
}
else
{
gainCalculations.Add("Long", null);
}
if (midSinGain.HasValue)
{
gainCalculations.Add("Mid", midSinGain.GetValueOrDefault());
}
else
{
gainCalculations.Add("Mid", null);
}
if (shortSinGain.HasValue)
{
gainCalculations.Add("Short", shortSinGain.GetValueOrDefault());
}
else
{
gainCalculations.Add("Short", null);
}
var longSinAcc = new double?();
if (accuracyKspDiffValues.Where(x => x.Key == 240D).Count() > 0 && accuracyKspSpotValues.Where(x => x.Key == 240D).Count() > 0)
{
var longSinW1 = accuracyKspDiffValues.Where(x => x.Key == 240D).Select(x => x.Value).Sum();
var longSinW2 = accuracyKspSpotValues.Where(x => x.Key == 240D).Select(x => x.Value).Sum();
longSinAcc = 1D - (longSinW1 / longSinW2);
}
var midSinAcc = new double?();
if (accuracyKspDiffValues.Where(x => x.Key == 120D).Count() > 0 && accuracyKspDiffValues.Where(x => x.Key == 120D).Count() > 0)
{
var midSinW1 = accuracyKspDiffValues.Where(x => x.Key == 120D).Select(x => x.Value).Sum();
var midSinW2 = accuracyKspSpotValues.Where(x => x.Key == 120D).Select(x => x.Value).Sum();
midSinAcc = 1D - (midSinW1 / midSinW2);
}
var shortSinAcc = new double?();
if (accuracyKspDiffValues.Where(x => x.Key == 30D).Count() > 0 && accuracyKspDiffValues.Where(x => x.Key == 30D).Count() > 0)
{
var shortSinW1 = accuracyKspDiffValues.Where(x => x.Key == 30D).Select(x => x.Value).Sum();
var shortSinW2 = accuracyKspSpotValues.Where(x => x.Key == 30D).Select(x => x.Value).Sum();
shortSinAcc = 1D - (shortSinW1 / shortSinW2);
}
else
{
shortSinAcc = null;
}
var accuracyCalculations = new Dictionary <string, double?>();
accuracyCalculations.Add("Long", longSinAcc);
accuracyCalculations.Add("Mid", midSinAcc);
accuracyCalculations.Add("Short", shortSinAcc);
return(new PursuitGainCalculations {
Gains = gainCalculations, Accuracies = accuracyCalculations,
FilteredControlWindows = filteredControlWindows
});
}
public void AddAndRemoveFilteredFieldTest()
{
using (ShimsContext.Create())
{
// Assign
string strClass;
string strFieldValue;
string strFieldId;
string strFieldName;
string strCompareOperator;
string strLogicalOperator;
FilterController filterController;
RedirectResult result;
FieldViewModel model;
ISpeciesObservationFieldDescription fieldDescription;
ISpeciesObservationFieldSearchCriteria expectedField =
new SpeciesObservationFieldSearchCriteria()
{
Class = new SpeciesObservationClass()
{
Id = SpeciesObservationClassId.DarwinCore
},
Operator = CompareOperator.Like,
Property = new SpeciesObservationProperty()
{
Id = SpeciesObservationPropertyId.Owner
},
Type = DataType.String,
Value = "flodin"
};
filterController = new FilterController();
strClass = "DarwinCore";
strFieldValue = "flodin";
strFieldId = "146";
strFieldName = "Owner";
strCompareOperator = "LIKE";
strLogicalOperator = "OR";
model = new FieldViewModel();
model.FieldDescriptionTypes = new FieldViewModel.SpeciesObservationFieldDescriptionType();
model.FieldDescriptionTypes.FieldDescriptionTypes = new Dictionary <string, List <ISpeciesObservationFieldDescription> >();
fieldDescription = new SpeciesObservationFieldDescription();
fieldDescription.Type = DataType.String;
model.FieldDescriptionTypes.FieldDescriptionTypes.Add(strClass, new List <ISpeciesObservationFieldDescription> {
fieldDescription
});
// Act
ActionResult viewResult = filterController.Field();
// Test add field to MySettings
result = filterController.AddFieldToFilter(
strClass,
strFieldValue,
strFieldId,
strFieldName,
strCompareOperator,
strLogicalOperator,
"Home/Index");
// Assert
Assert.IsNotNull(viewResult);
Assert.IsTrue(result.Url == "Home/Index");
Assert.AreEqual(expectedField.Type, fieldDescription.Type);
Assert.IsTrue(SessionHandler.MySettings.Filter.Field.FieldFilterExpressions.Count == 1);
Assert.IsTrue(SessionHandler.MySettings.Filter.Field.FieldFilterExpressions[0].Class.Id.Equals(expectedField.Class.Id));
Assert.IsTrue(SessionHandler.MySettings.Filter.Field.FieldFilterExpressions[0].Value.Equals(expectedField.Value));
Assert.IsTrue(SessionHandler.MySettings.Filter.Field.FieldLogicalOperator == LogicalOperator.Or);
// Test remove field from MySettings
result = filterController.ResetFields("Home/Index");
Assert.IsTrue(result.Url == "Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Field.FieldFilterExpressions.Count == 0);
Assert.IsTrue(SessionHandler.MySettings.Filter.Field.FieldLogicalOperator == LogicalOperator.And);
}
}
public IObservable <IChangeSet <Node <TObject, TKey>, TKey> > Run()
{
return(Observable.Create <IChangeSet <Node <TObject, TKey>, TKey> >(observer =>
{
var locker = new object();
var filter = new FilterController <Node <TObject, TKey> >();
filter.Change(node => node.IsRoot);
var allData = _source.Synchronize(locker).AsObservableCache();
//for each object we need a node which provides
//a structure to set the parent and children
var allNodes = allData.Connect()
.Synchronize(locker)
.Transform((t, v) => new Node <TObject, TKey>(t, v))
.DisposeMany()
.AsObservableCache();
//as nodes change, maintain parent and children
var parentSetter = allNodes.Connect()
.Subscribe(changes =>
{
var grouped = changes.GroupBy(c => _pivotOn(c.Current.Item));
foreach (var group in grouped)
{
var parentKey = group.Key;
var parent = allNodes.Lookup(parentKey);
if (!parent.HasValue)
{
//deal with items which have no parent
foreach (var change in group)
{
change.Current.Parent = null;
switch (change.Reason)
{
case ChangeReason.Add:
break;
case ChangeReason.Update:
{
//copy children to the new node amd set parent
var children = change.Previous.Value.Children.Items;
change.Current.Update(updater => updater.AddOrUpdate(children));
children.ForEach(child => child.Parent = change.Current);
//remove from old parent if different
var previous = change.Previous.Value;
var previousParent = _pivotOn(previous.Item);
if (!previousParent.Equals(previous.Key))
{
allNodes.Lookup(previousParent)
.IfHasValue(n => { n.Update(u => u.Remove(change.Key)); });
}
break;
}
case ChangeReason.Remove:
{
//remove children and null out parent
var children = change.Current.Children.Items;
change.Current.Update(updater => updater.Remove(children));
children.ForEach(child => child.Parent = null);
break;
}
}
}
}
else
{
//deal with items have a parent
parent.Value.Update(updater =>
{
var p = parent.Value;
foreach (var change in group)
{
var previous = change.Previous;
var node = change.Current;
var key = node.Key;
switch (change.Reason)
{
case ChangeReason.Add:
{
// update the parent node
node.Parent = p;
updater.AddOrUpdate(node);
break;
}
case ChangeReason.Update:
{
//copy children to the new node amd set parent
var children = previous.Value.Children.Items;
change.Current.Update(u => u.AddOrUpdate(children));
children.ForEach(child => child.Parent = change.Current);
//check whether the item has a new parent
var previousItem = previous.Value.Item;
var previousKey = previous.Value.Key;
var previousParent = _pivotOn(previousItem);
if (!previousParent.Equals(previousKey))
{
allNodes.Lookup(previousParent)
.IfHasValue(n => { n.Update(u => u.Remove(key)); });
}
//finally update the parent
node.Parent = p;
updater.AddOrUpdate(node);
break;
}
case ChangeReason.Remove:
{
node.Parent = null;
updater.Remove(key);
var children = node.Children.Items;
change.Current.Update(u => u.Remove(children));
children.ForEach(child => child.Parent = null);
break;
}
}
}
});
}
}
filter.Reevaluate();
});
var result = allNodes.Connect(filter).SubscribeSafe(observer);
return Disposable.Create(() =>
{
result.Dispose();
parentSetter.Dispose();
allData.Dispose();
allNodes.Dispose();
filter.Dispose();
});
}));
}
public void SetUp()
{
commandFactory = MockRepository.GenerateStub <ICommandFactory>();
taskManager = MockRepository.GenerateStub <ITaskManager>();
controller = new FilterController(commandFactory, taskManager);
}
public void AddAndRemoveFilteredTaxaTest()
{
using (ShimsContext.Create())
{
int[] taxaIds;
string strJson;
FilterController filterController;
RedirectResult result;
JsonNetResult result2;
JsonModel jsonResult;
List <TaxonViewModel> taxaListResult;
filterController = new FilterController();
taxaIds = new int[] { 1, 2, 5 };
strJson = JsonConvert.SerializeObject(taxaIds);
ActionResult viewResult = filterController.TaxonFromIds();
Assert.IsNotNull(viewResult);
// Test add taxa to MySettings
result = filterController.AddTaxaToFilter(strJson, "Home/Index");
Assert.IsTrue(result.Url == "Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(1));
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(2));
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(5));
Assert.IsFalse(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(3));
// Test remove taxon from MySettings
result = filterController.RemoveFilteredTaxon("Home/Index", 2);
Assert.IsTrue(result.Url == "Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(1));
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(5));
Assert.IsFalse(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(2));
// Test Get filtered taxa
result2 = filterController.GetFilteredTaxa();
jsonResult = (JsonModel)result2.Data;
taxaListResult = (List <TaxonViewModel>)jsonResult.Data;
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total == 2);
Assert.IsTrue(taxaListResult.Count == 2);
int[] taxonIdsInList = new int[] { taxaListResult[0].TaxonId, taxaListResult[1].TaxonId };
Assert.IsTrue(taxonIdsInList.Contains(1));
Assert.IsTrue(taxonIdsInList.Contains(5));
Assert.IsFalse(taxonIdsInList.Contains(2));
// Remove all filtered taxa
Assert.AreEqual(2, SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count);
result = filterController.RemoveAllFilteredTaxon("Home/Index");
Assert.AreEqual("Home/Index", result.Url);
Assert.AreEqual(0, SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count);
// Test Get filtered taxa with unexpected error
MakeGetCurrentUserFunctionCallThrowException();
result2 = filterController.GetFilteredTaxa();
jsonResult = (JsonModel)result2.Data;
Assert.IsFalse(jsonResult.Success);
Assert.IsNull(jsonResult.Data);
}
}
public void Init()
{
aMockSalesService = new Mock<ISalesService>();
controller= new FilterController();
}
private void FilteringCriterionListAction_Execute(object sender, SingleChoiceActionExecuteEventArgs e)
{
// Глушим стандартный полнотекстовый поиск
standardFilterController.FullTextFilterAction.Enabled[FTS_DO_NOT_ENABLED] = false;
ListViewClearFilter.Enabled[DO_NOT_ENABLED] = true;
ListViewApplyFilter.Enabled[DO_NOT_ENABLED] = true;
// В зависимости от выбранного пункта вызывается та или иная форма
//frame = Frame;
//view = View;
//listView = view as DevExpress.ExpressApp.ListView;
if (listView == null)
{
return;
}
// Находим, если задан, фильтр из модели
string choiceActionItemFilterString = "";
FilterController fc = Frame.GetController <FilterController>();
ChoiceActionItem choiceActionItem = ((SingleChoiceAction)(fc.Actions["SetFilter"])).SelectedItem;
if (choiceActionItem != null)
{
choiceActionItemFilterString = choiceActionItem.Data.ToString();
}
if (e.SelectedChoiceActionItem.Id == "CriteriaBuilder")
{
// Показ формы построения запроса с помощью построителя критериев
if (FilterIsShowihg)
{
if (currentFilterId == "CriteriaBuilder")
{
FilterPanelHide();
return;
}
}
currentFilterId = "CriteriaBuilder";
FilterIsShowihg = true;
// Разблокируем кнопку применения фильтра
ListViewApplyFilter.Enabled.Clear();
ListViewApplyFilter.Enabled[DO_NOT_ENABLED] = true;
// Тип объекта-фильтра
Type filterObjType = typeof(FilteringCriterion);
string strCriteria = this.criteriaBuilderString;
IObjectSpace objectSpace = frame.Application.CreateObjectSpace();
FilteringCriterion objFilter = objectSpace.CreateObject(filterObjType) as FilteringCriterion; // objectSpace.GetObject(currentObject);
if (objFilter == null)
{
return;
}
//objFilter.LV = listView;
objFilter.objectTypeInfo = objectTypeInfo;
//objFilter.CriteriaController = this;
objFilter.Criterion = strCriteria; // Остаётся для построителя запросов в форме FilteringCriterion.cs
//objFilter.AdditionalCriterionString = choiceActionItemFilterString;
wp = objFilter as ICustomFilter;
if (wp == null)
{
return;
}
string DetailViewId = frame.Application.FindDetailViewId(objFilter.GetType());
DetailView newView = frame.Application.CreateDetailView(objectSpace, DetailViewId, false, objFilter);
newView.CreateControls();
filterPanel.Controls.Clear();
DevExpress.ExpressApp.Win.Layout.XafLayoutControl ctrlFilter = ((DevExpress.ExpressApp.Win.Layout.XafLayoutControl)newView.Control);
filterPanel.Controls.Add(ctrlFilter);
FilteringCriterionListAction.SelectedIndex = 0;
FilterPanelShow(130);
return;
}
if (e.SelectedChoiceActionItem.Data != null)
{
// Показ формы с полями от NonPersistent объекта, через которую формировать критерий поиска, присваивать его
// списку и reload() этого списка
// Разблокируем кнопку применения фильтра
ListViewApplyFilter.Enabled.Clear();
ListViewApplyFilter.Enabled[DO_NOT_ENABLED] = true;
IModelDetailView node = e.SelectedChoiceActionItem.Data as IModelDetailView;
// Тип объекта-фильтра
Type filterObjType = node.ModelClass.TypeInfo.Type;
string strCriteria = this.criteriaBuilderString;
IObjectSpace objectSpace = frame.Application.CreateObjectSpace();
ICustomFilter objFilter = objectSpace.CreateObject(filterObjType) as ICustomFilter;
if (objFilter == null)
{
return;
}
//objFilter.LV = listView;
objFilter.objectTypeInfo = objectTypeInfo;
//objFilter.CriteriaController = this;
//objFilter.AdditionalCriterionString = choiceActionItemFilterString;
//objFilter.Criterion = strCriteria;
string DetailViewId = frame.Application.FindDetailViewId(objFilter.GetType());
if (FilterIsShowihg & currentFilterId == DetailViewId)
{
FilterPanelHide();
return;
}
currentFilterId = DetailViewId;
FilterIsShowihg = true;
wp = objFilter as ICustomFilter;
if (wp == null)
{
return;
}
DetailView newView = frame.Application.CreateDetailView(objectSpace, DetailViewId, false, objFilter);
newView.CreateControls();
filterPanel.Controls.Clear();
DevExpress.ExpressApp.Win.Layout.XafLayoutControl ctrlFilter = ((DevExpress.ExpressApp.Win.Layout.XafLayoutControl)newView.Control);
filterPanel.Controls.Add(ctrlFilter);
FilteringCriterionListAction.SelectedIndex = 0;
//FilterPanelShow(100);
FilterPanelShow(GetFilterHight(newView) + 30);
return;
}
}
public void Initialise()
{
_source = new SourceList<Person>();
_filter = new FilterController<Person>(p => p.Age > 20);
_results = _source.Connect().Filter(_filter, FilterPolicy.ClearAndReplace).AsAggregator();
}
public static IObservable <(FilterController sender, CreateCustomSearchCriteriaBuilderEventArgs e)> WhenCreateCustomSearchCriteriaBuilder(this FilterController controller) => Observable
public static FilterController Fixture()
{
FilterController controller = new FilterController(new FilterRepository(), "", new LoginView());
return controller;
}
/// <summary>
/// Filters source using the specified filter controller.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="source">The source.</param>
/// <param name="filterController">The filter controller.</param>
/// <returns></returns>
/// <exception cref="System.ArgumentNullException">source
/// or
/// filterController</exception>
public static IObservable <IChangeSet <T> > Where <T>(this IObservable <IChangeSet <T> > source, FilterController <T> filterController)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (filterController == null)
{
throw new ArgumentNullException(nameof(filterController));
}
return(source.Filter(filterController));
}
public void ViewObservations()
{
//Arrange
// Set language to swedish since reference data is on that language
SetSwedishLanguage();
FilterController filterController = new FilterController();
ResultController resultController = new ResultController();
// TODO Add tests for presentation controller data
FormatController presentationController = new FormatController();
//Act and Assert
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count == 0);
filterController.RemoveAllFilteredTaxon("Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count == 0);
int[] taxaIds = new int[] { 100573 };
string strJson = JsonConvert.SerializeObject(taxaIds);
filterController.AddTaxaToFilter(strJson, "Home/Index");
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Contains(100573));
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.TaxonIds.Count == 1);
//**************************** Set spatial data ***************************************************
Polygon polygon1 = CreateTestPolygon1();
var feature1 = new Feature(polygon1);
var features = new List <Feature> {
feature1
};
var featureCollection = new FeatureCollection(features);
string geojson = JsonConvert.SerializeObject(featureCollection, JsonHelper.GetDefaultJsonSerializerSettings());
// Update spatial filter
JsonNetResult filterResult = filterController.UpdateSpatialFilter(geojson);
JsonModel jsonFilterResult = (JsonModel)filterResult.Data;
Assert.IsTrue(jsonFilterResult.Success);
Assert.IsTrue(SessionHandler.MySettings.Filter.Spatial.IsActive == true);
Assert.IsTrue(SessionHandler.MySettings.Filter.Spatial.Polygons.Count == 1);
//**************************** Check map data *******************************************************
// Sow map view for Griffelblomfluga
ViewResult pvResult = resultController.SpeciesObservationMap();
Assert.IsNotNull(pvResult);
// Test that correct view is returned, Todo: No view is returned, delete?
// Assert.AreEqual("SpeciesObservationMap", pvResult.ViewName);
//Get the map data to be shown
JsonNetResult obsMap = resultController.GetObservationsAsGeoJSON();
Assert.IsNotNull(obsMap.Data);
var jsonMapResult = (JsonModel)obsMap.Data;
var noObs = (SpeciesObservationsGeoJsonModel)jsonMapResult.Data;
int numberOfObservations = noObs.Points.Features.Count;
//Check settings
Assert.IsTrue(SessionHandler.MySettings.Presentation.Map.IsActive);
Assert.IsFalse(SessionHandler.MySettings.Presentation.Table.IsActive);
Assert.IsTrue(SessionHandler.MySettings.Filter.Taxa.IsActive);
//************************ Check table data *********************************************
var result = resultController.SpeciesObservationTable() as ViewResult;
Assert.IsNotNull(result);
// Test that correct view is returned
Assert.AreEqual("Table", result.ViewName);
var viewModel = result.ViewData.Model as ViewTableViewModel;
Assert.IsNotNull(viewModel);
var obsResult = resultController.GetPagedObservationListAsJSON(1, 0, 25);
Assert.IsNotNull(obsResult);
JsonModel jsonResult = (JsonModel)obsResult.Data;
List <Dictionary <string, string> > observationListResult = (List <Dictionary <string, string> >)jsonResult.Data;
Assert.IsNotNull(jsonResult);
Assert.IsTrue(jsonResult.Success);
Assert.IsTrue(jsonResult.Total > 20);
Assert.IsTrue(observationListResult.Count > 20);
Assert.IsTrue(numberOfObservations == observationListResult.Count, "Number of observations differs between Map and ObsTable");
BaseDataTest.VerifyObservationDataForGriffelblomfluga1000573(observationListResult);
//*********************** Check detailsPanel ****************************************************
string observationGUID = observationListResult[20]["ObservationId"];
DetailsController detailsController = new DetailsController();
//Act
// Returning "hard coded" value för first observation for griffelblomfluga
var detailsResult = detailsController.ObservationDetail(observationGUID) as ViewResult;
//Assert
Assert.IsNotNull(detailsResult);
var detailsViewModel = detailsResult.ViewData.Model as ObservationDetailViewModel;
Assert.IsNotNull(detailsViewModel);
// Test that correct view is returned
Assert.AreEqual("Detail", detailsResult.ViewName);
//Check number of properties
Assert.IsTrue(detailsViewModel.Fields.Count > 10);
// Reset to english language
SetEnglishLanguage();
}
public void SingleSlotOperations()
{
// Arrange
TimeController tc = new TimeController();
FilterController fc = new FilterController();
HttpResponseMessage response;
long currentId;
Slot foundSlot;
DateTime start = DateTime.Today;
DateTime end = DateTime.Now;
string desc = "A daily dummy job";
string project = "Test";
// Act
Dictionary <string, string> data = new Dictionary <string, string>
{
{ "ID", "#" },
{ "Start", start.ToString("yyyy-MM-ddTHH:mm:ss") }, // Firefox
{ "End", end.ToString("yyyy-MM-ddTHH:mm") }, // Chrome
{ "Description", desc },
{ "Project", project },
};
response = tc.Post(new FormDataCollection(data));
foundSlot = fc.GetSlots().First();
currentId = foundSlot.ID;
// Assert
Assert.IsTrue(response.IsSuccessStatusCode);
Assert.IsTrue(Math.Abs(foundSlot.Start.Subtract(start).TotalMinutes) < 1);
Assert.IsTrue(Math.Abs(foundSlot.End.Subtract(end).TotalMinutes) < 1);
Assert.AreEqual(foundSlot.Description, desc);
Assert.AreEqual(foundSlot.Project, project);
// Act
foundSlot = tc.Get(currentId);
// Assert
Assert.IsTrue(Math.Abs(foundSlot.Start.Subtract(start).TotalMinutes) < 1);
Assert.IsTrue(Math.Abs(foundSlot.End.Subtract(end).TotalMinutes) < 1);
Assert.AreEqual(foundSlot.Description, desc);
Assert.AreEqual(foundSlot.Project, project);
// Act
string newDesc = "An updated activity description";
data["ID"] = currentId.ToString();
data["Description"] = newDesc;
response = tc.Post(new FormDataCollection(data));
foundSlot = tc.Get(currentId);
// Assert
Assert.IsTrue(response.IsSuccessStatusCode);
Assert.IsTrue(Math.Abs(foundSlot.Start.Subtract(start).TotalMinutes) < 1);
Assert.IsTrue(Math.Abs(foundSlot.End.Subtract(end).TotalMinutes) < 1);
Assert.AreEqual(foundSlot.Description, newDesc);
Assert.AreEqual(foundSlot.Project, project);
// Act
response = tc.Delete(currentId);
// Assert
Assert.IsTrue(response.IsSuccessStatusCode);
// Act
try
{
foundSlot = tc.Get(currentId);
Assert.Fail();
}
catch (HttpResponseException)
{
Assert.Pass();
}
}
private void FilterSave()
{
FilterInfo filter = new FilterInfo();
filter.FilterId = -1;
filter.ModuleId = ModuleId;
filter.PortalId = PortalId;
if (Params.ContainsKey("FilterId"))
{
filter.FilterId = Convert.ToInt32(Params["FilterId"]);
}
if (Params.ContainsKey("Find"))
{
filter.Find = Params["Find"].ToString();
}
if (Params.ContainsKey("Replacement"))
{
filter.Replace = Params["Replacement"].ToString();
}
if (Params.ContainsKey("FilterType"))
{
filter.FilterType = Params["FilterType"].ToString();
}
FilterController fc = new FilterController();
filter = fc.Filter_Save(filter);
}
public static void SwitchFilter(this FilterController controller, FILTER_TYPE type, int index)
{
controller.InvokeMethod("OnClickBtn", controller.GetField <ButtonArray[]>("BtnArray")[(int)type][index].gameObject);
}
public void Initialise()
{
_source = new SourceCache <Person, string>(p => p.Key);
_filter = new FilterController <Person>(p => p.Age > 20);
_results = new ChangeSetAggregator <Person, string>(_source.Connect(_filter));
}
public FilterControllerFixtureWithClearAndReplace()
{
_source = new SourceList <Person>();
_filter = new FilterController <Person>(p => p.Age > 20);
_results = _source.Connect().Filter(_filter).AsAggregator();
}
public void Initialise()
{
_source = new SourceList <Person>();
_filter = new FilterController <Person>(p => p.Age > 20);
_results = _source.Connect().Filter(_filter, FilterPolicy.CalculateDiffSet).AsAggregator();
}
public void Can_Filter()
{
//Arrange
Mock <ISportHalRepository> mock = new Mock <ISportHalRepository>();
mock.Setup(m => m.SportsHall).Returns(new SportsHall[]
{
new SportsHall
{
Length = 100,
Width = 50,
NumberOfDressingSpace = 40,
NumberOfShowers = 10,
OpenTime = new DateTime(1990, 1, 1, 8, 0, 0),
CloseTime = new DateTime(1990, 1, 1, 17, 0, 0),
Price = 100,
SportsBuilding = new SportsBuilding
{
Name = "TrefPunt",
Canteen = true,
City = "Rijsbergen",
Street = "Rechtweg",
PostalCode = "4891 CP",
HouseNumber = 5,
},
SportsHallSports = new SportsHallSports[]
{
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Voetbal"
}
},
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Badminton"
}
},
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Basketbal"
}
}
}
},
new SportsHall
{
Length = 100,
Width = 50,
NumberOfDressingSpace = 40,
NumberOfShowers = 10,
OpenTime = new DateTime(1990, 1, 1, 8, 0, 0),
CloseTime = new DateTime(1990, 1, 1, 17, 0, 0),
Price = 100,
SportsBuilding = new SportsBuilding
{
Name = "TrefPunt",
Canteen = true,
City = "Rijsbergen",
Street = "Rechtweg",
PostalCode = "4891 CP",
HouseNumber = 5,
},
SportsHallSports = new SportsHallSports[]
{
new SportsHallSports {
SportsHallId = 2, Sport = new Sport {
Name = "Voetbal"
}
},
new SportsHallSports {
SportsHallId = 2, Sport = new Sport {
Name = "Badminton"
}
},
}
}, new SportsHall
{
Length = 100,
Width = 50,
NumberOfDressingSpace = 40,
NumberOfShowers = 10,
OpenTime = new DateTime(1990, 1, 1, 8, 0, 0),
CloseTime = new DateTime(1990, 1, 1, 17, 0, 0),
Price = 100,
SportsBuilding = new SportsBuilding
{
Name = "TrefPunt",
Canteen = false,
City = "Rijsbergen",
Street = "Rechtweg",
PostalCode = "4891 CP",
HouseNumber = 5,
},
SportsHallSports = new SportsHallSports[]
{
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Voetbal"
}
},
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Badminton"
}
},
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Basketbal"
}
}
}
},
new SportsHall
{
Length = 100,
Width = 50,
NumberOfDressingSpace = 50,
NumberOfShowers = 20,
OpenTime = new DateTime(1990, 1, 1, 8, 0, 0),
CloseTime = new DateTime(1990, 1, 1, 17, 0, 0),
Price = 100,
SportsBuilding = new SportsBuilding
{
Name = "DeZaal",
Canteen = true,
City = "Etten-Leur",
Street = "Scheefweg",
PostalCode = "2000 GP",
HouseNumber = 4,
},
SportsHallSports = new SportsHallSports[]
{
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Voetbal"
}
},
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Basketbal"
}
},
}
},
new SportsHall
{
Length = 50,
Width = 20,
NumberOfDressingSpace = 40,
NumberOfShowers = 10,
OpenTime = new DateTime(1990, 1, 1, 8, 0, 0),
CloseTime = new DateTime(1990, 1, 1, 17, 0, 0),
Price = 100,
SportsBuilding = new SportsBuilding
{
Name = "DeZaal",
Canteen = true,
City = "Etten-Leur",
Street = "Scheefweg",
PostalCode = "2000 GP",
HouseNumber = 4,
},
SportsHallSports = new SportsHallSports[]
{
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Badminton"
}
},
new SportsHallSports {
SportsHallId = 1, Sport = new Sport {
Name = "Basketbal"
}
}
}
},
}
);
FilterController controller = new FilterController(mock.Object);
//Act
FilterViewModel model = controller.FilterView("Basketbal", null, 100, 50, 20, 10, "on", false, null, null, 100)
.ViewData.Model as FilterViewModel;
//Assert
IEnumerable <SportsHall> result = model.SportsHalls;
SportsHall[] sporthallArray = result.ToArray();
Assert.True(sporthallArray.Length == 2);
//Hall 1
Assert.Equal(20, sporthallArray[0].NumberOfShowers);
Assert.Equal(50, sporthallArray[0].NumberOfDressingSpace);
Assert.True(sporthallArray[0].SportsHallSports.Select(x => x.Sport).ToList().Count() == 2);
Assert.Equal(true, sporthallArray[0].SportsBuilding.Canteen);
//Hall 2
Assert.Equal(10, sporthallArray[1].NumberOfShowers);
Assert.Equal(40, sporthallArray[1].NumberOfDressingSpace);
Assert.True(sporthallArray[1].SportsHallSports.Select(x => x.Sport).ToList().Count() == 3);
Assert.Equal(true, sporthallArray[1].SportsBuilding.Canteen);
}
