public IEnumerable <Establishment> FindEstablishments(EstablishmentFilter filter = null)
{
int pages;
filter = filter ?? new EstablishmentFilter();
filter.Page = 0;
PreRequest?.Invoke(filter);
var response = _client.FindEstablishments(filter, out pages);
PostRequest?.Invoke(filter, response);
foreach (var establishment in response)
{
yield return(establishment);
}
for (var i = 1; i < pages; i++)
{
filter.Page = i;
PreRequest?.Invoke(filter);
response = _client.FindEstablishments(filter, out pages);
PostRequest?.Invoke(filter, response);
foreach (var establishment in response)
{
yield return(establishment);
}
}
}
private async Task <FindEstablishmentsResponse> RequestEstablishments(EstablishmentFilter filter)
{
PreRequest?.Invoke(filter);
var response = await _client.FindEstablishmentsAsync(new FindEstablishmentsRequest(filter));
PostRequestAsync?.Invoke(filter, response);
return(response);
}
public async Task <List <Establishment> > FindEstablishmentsAsync(EstablishmentFilter filter = null)
{
var list = new List <Establishment>();
filter = filter ?? new EstablishmentFilter();
filter.Page = 0;
var response = await RequestEstablishments(filter);
list.AddRange(response.Establishments);
for (var i = 1; i < response.PageCount; i++)
{
filter.Page = i;
list.AddRange((await RequestEstablishments(filter)).Establishments);
}
return(list);
}
public async Task ShouldQueryForHeiProviders()
{
var client = new Mock <IEstablishmentClient>();
var handler = new HeiProviderHandler(Mock.Of <ILog>(), client.Object);
EstablishmentFilter filter = null;
client.Setup(m => m.FindEstablishmentsAsync(It.IsAny <EstablishmentFilter>()))
.Callback <EstablishmentFilter>(model => filter = model)
.ReturnsAsync(new EstablishmentList());
await handler.Handle(new HeiProvidersRequest());
filter.Page.Should().Be(0);
filter.TypeOfEstablishment.Should().Be(EstablishmentType.HigherEducationInstitutions);
filter.Fields.Count.Should().Be(1);
filter.Fields.Should().Contain("UKPRN");
}
public async Task <ICollection <EducationOrganisation> > GetOrganisations()
{
var client = _factory.Create();
var filter = new EstablishmentFilter
{
Fields = new StringList {
"EstablishmentName", "TypeOfEstablishment", "Street", "Locality", "Address3", "Town", "County", "Postcode", "URN"
}
};
try
{
var establishments = await client.FindEstablishmentsAsync(filter);
if (!establishments.Any())
{
return(new EducationOrganisation[0]);
}
return(establishments.Select(x => new EducationOrganisation
{
Name = x.EstablishmentName,
EducationalType = x.TypeOfEstablishment?.DisplayName ?? string.Empty,
AddressLine1 = x.Street,
AddressLine2 = x.Locality,
AddressLine3 = x.Address3,
Town = x.Town,
County = x.County?.DisplayName ?? string.Empty,
PostCode = x.Postcode,
URN = x.URN
}).ToArray());
}
catch (Exception e)
{
_logger.Error(e, "Could not get organisations from Edubase API");
}
return(new EducationOrganisation[0]);
}
public void ShouldIgnoreThePageIfItsExplicitlyStated()
{
// Arrange
int pages = 2;
var pageCallbacks = new List <int>();
var mockClient = new Mock <IEdubaseClient>();
var sut = new EstablishmentClient(mockClient.Object);
mockClient.Setup(x => x.FindEstablishments(It.IsAny <EstablishmentFilter>(), out pages)).Returns(new EstablishmentList())
.Callback <EstablishmentFilter, int>((x, y) => pageCallbacks.Add(x.Page));
var filter = new EstablishmentFilter {
Page = 1
};
// Act
sut.FindEstablishments(filter).ToList();
// Assert
mockClient.Verify(x => x.FindEstablishments(It.IsAny <EstablishmentFilter>(), out pages), Times.Exactly(2));
CollectionAssert.Contains(pageCallbacks, 0);
CollectionAssert.Contains(pageCallbacks, 1);
}
/// <summary>
/// Return establishment list.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public ListResult <EstablishmentListDTO> List(EstablishmentFilter filter)
{
IAggregateFluent <Establishment> establishmentAggregateFluent = this.MongoRepository
.GetCollection <Establishment>().Aggregate();
if (filter.GeospatialQuery)
{
if (!filter.Meters.HasValue)
{
filter.Meters = 10000;
}
BsonDocument geoNearOptions = new BsonDocument {
{
"near", new BsonDocument {
{ "type", "Point" },
{ "coordinates", new BsonArray {
filter.Longitude.Value, filter.Latitude.Value
} },
}
},
{ "maxDistance", filter.Meters },
{ "includeLocs", "Location.Coordinates" },
{ "distanceField", "Location.Distance" },
{ "spherical", true }
};
establishmentAggregateFluent = establishmentAggregateFluent.AppendStage(
(PipelineStageDefinition <Establishment, Establishment>) new BsonDocument {
{ "$geoNear", geoNearOptions }
}
);
this.TelemetryClient.TrackEvent(
EventNames.EstablishmentListLocation,
new { filter.Latitude, filter.Longitude }
);
}
if (filter.EstablishmentType.HasValue)
{
establishmentAggregateFluent = establishmentAggregateFluent
.Match(document => document.EstablishmentTypes.Contains(filter.EstablishmentType.Value));
this.TelemetryClient.TrackEvent(
EventNames.EstablishmentListType,
new { filter.EstablishmentType }
);
}
if (!string.IsNullOrEmpty(filter.Query))
{
establishmentAggregateFluent = establishmentAggregateFluent.Match(
document => document.Name.Contains(filter.Query) ||
document.Description.Contains(filter.Query)
);
this.TelemetryClient.TrackEvent(
EventNames.EstablishmentListQuery,
new { filter.Query }
);
}
if (filter.DaysOfWeekEnum != null)
{
Expression <Func <Establishment, bool> > availabilityExpression = document => false;
foreach (DayOfWeekEnum dayOfWeek in filter.DaysOfWeekEnum)
{
availabilityExpression = availabilityExpression.Or(
document => document.Availabilities.Any(
availability => availability.DayOfWeek == dayOfWeek || availability.CloseDayOfWeek == dayOfWeek
)
);
}
establishmentAggregateFluent = establishmentAggregateFluent.Match(availabilityExpression);
this.TelemetryClient.TrackEvent(
EventNames.EstablishmentListDaysOfWeek,
new { filter.DaysOfWeek }
);
}
IAggregateFluent <BsonDocument> aggregateFluent = establishmentAggregateFluent.As <BsonDocument>();
aggregateFluent = filter.OrderType == OrderTypeEnum.Distance
? aggregateFluent.SortBy(document => document["Location"]["Distance"])
: aggregateFluent.SortByDescending(document => document["Relevance"]);
if (!this.UserContext.EstablishmentId.HasValue)
{
this.RelevanceService.Register <Establishment, EstablishmentFilter>(filter);
}
IEnumerable <BsonDocument> documents = aggregateFluent
.Skip((filter.Page - 1) * filter.PageSize)
.Limit(filter.PageSize)
.ToList();
IEnumerable <EstablishmentListDTO> establishments = documents.Select(document =>
new EstablishmentListDTO
{
Id = document["_id"].AsObjectId,
EstablishmentTypes = document["EstablishmentTypes"].AsBsonArray.Select(x => (EstablishmentTypeEnum)x.AsInt32),
ImageThumbnail = document["ImageThumbnail"]["Uri"].AsString,
Name = document["Name"].AsString,
Distance = document["Location"].AsBsonDocument.Contains("Distance")
? document["Location"]["Distance"].AsDouble
: (double?)null
}
).ToList();
return(new ListResult <EstablishmentListDTO>(
establishments,
aggregateFluent.Count().FirstOrDefault()?.Count ?? 0,
filter
));
}
public IActionResult Get([FromQuery] EstablishmentFilter filter)
{
return(Ok(this.EstablishmentService.List(filter)));
}
