public async Task CourseSearchAsyncCatchesExceptionWhenApiReturnsNotSuccessful()
{
// Arrange
var courseSearchRequest = new CourseSearchRequest {
SubjectKeyword = "Somekeyword"
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Throws <Exception>();
var auditService = A.Fake <IAuditService>();
using var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
using var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
// Act
var result = await findACourseClient.CourseSearchAsync(courseSearchRequest).ConfigureAwait(false);
// Assert
Assert.Null(result);
}
public async Task CourseSearchAsyncReturnsHttpRequestExceptionWhenApiReturnsNotSuccessful()
{
// Arrange
var courseSearchRequest = new CourseSearchRequest {
SubjectKeyword = "Somekeyword"
};
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.ServiceUnavailable, Content = new StringContent("{}")
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var auditService = A.Fake <IAuditService>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
// Act
await Assert.ThrowsAsync <HttpRequestException>(async() => await findACourseClient.CourseSearchAsync(courseSearchRequest).ConfigureAwait(false)).ConfigureAwait(false);
// Assert
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task CourseSearchAsyncReturnsBlankResultsWhenApiReturnsBadRequest()
{
// Arrange
var courseSearchRequest = new CourseSearchRequest {
SubjectKeyword = "Somekeyword"
};
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.BadRequest, Content = new StringContent("{}")
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var auditService = A.Fake <IAuditService>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
var result = await findACourseClient.CourseSearchAsync(courseSearchRequest).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.Empty(result.Results);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
public async Task InitCourses()
{
TotalStudents = await courseService.GetTotalStudentsFromInstructorsCourses <int>(User.UserID);
TotalCourses = await courseService.GetTotalInstructorsCourses <int>(User.UserID);
TotalRating = await courseService.GetAverageInstructorsCoursesRating <float>(User.UserID);
try
{
CourseSearchRequest request = new CourseSearchRequest()
{
UserID = User.UserID
};
InstructorList.Clear();
var courses = await courseService.Get <List <MCourse> >(request);
foreach (var course in courses)
{
if (courses.Count > 0)
{
InstructorList.Add(new CourseVM(course));
}
}
}
catch (Exception)
{
}
}
public async Task Init(CourseSearchRequest request = null)
{
try
{
var userID = SignedInUser.User.UserID;
courseList.Clear();
var courses = await courseService.GetLikedCourse(userID, request);
var usersBoughtCourses = await courseService.GetBoughtCourses(userID);
foreach (var course in courses)
{
var DoesItContain = usersBoughtCourses.Where(m => m.CourseID == course.CourseID).Any();
if (usersBoughtCourses.Count > 0)
{
if (DoesItContain == false)
{
courseList.Add(new CourseVM(course));
}
}
else
{
courseList.Add(new CourseVM(course));
}
}
}
catch (Exception)
{
}
}
private async Task LoadList(CourseSearchRequest request)
{
var result = await courseService.Get <List <MCourse> >(request);
dgvCourses.AutoGenerateColumns = false;
dgvCourses.ReadOnly = true;
dgvCourses.DataSource = result;
}
private async Task Search(object query)
{
var request = new CourseSearchRequest()
{
Name = query as string
};
await Init(request);
}
public async Task Init(MUser user)
{
try
{
if (categoryList.Count == 0)
{
categoryList.Clear();
var categories = await categoryService.Get <List <MCategory> >(null);
foreach (var category in categories)
{
categoryList.Add(category);
}
}
if (SelectedCategory != null)
{
int userID;
if (SelectedSubcategory != null)
{
CourseSearchRequest search1 = new CourseSearchRequest
{
SubcategoryID = _selectedSubcategory.SubcategoryID
};
courseList.Clear();
var courses = await courseService.Get <List <MCourse> >(search1);
foreach (var x in courses)
{
userID = SignedInUser.User.UserID;
var usersBoughtCourses = await courseService.GetBoughtCourses(userID);
var DoesItContain = usersBoughtCourses.Where(m => m.CourseID == x.CourseID).Any();
if (usersBoughtCourses.Count > 0)
{
if (DoesItContain == false && x.UserID != user.UserID)
{
courseList.Add(new CourseVM(x));
}
}
else if (x.UserID != user.UserID)
{
courseList.Add(new CourseVM(x));
}
}
}
}
}
catch (Exception)
{
}
}
public RequestParameterSerialisationTests()
{
courseSearchRequest = new CourseSearchRequest()
{
SubjectKeyword = "SearchTerm", SortBy = 1, Start = 2, Limit = 20
};
jsonMediaTypeFormatter = new JsonMediaTypeFormatter();
shouldContainParameters = new List <string> {
nameof(courseSearchRequest.SubjectKeyword), nameof(courseSearchRequest.SortBy), nameof(courseSearchRequest.Start), nameof(courseSearchRequest.Limit)
};
ms = new MemoryStream();
}
public async Task CourseSearch()
{
var courseSearchRequest = new CourseSearchRequest
{
SubjectKeyword = configuration.GetSection("CourseSearch:KeyWordsForTest").Get <string>(),
Start = 0,
Limit = 5,
};
var searchResponse = await findACourseClient.CourseSearchAsync(courseSearchRequest).ConfigureAwait(false);
searchResponse.Total.Should().BeGreaterThan(0);
}
private async void cbSubcategories_SelectedIndexChanged(object sender, EventArgs e)
{
var user = await userService.GetById <MUser>(_user.UserID);
MSubcategory subcategory;
foreach (var userRole in user.UserRoles)
{
int subcategoryID;
if (userRole.RoleID == 1)
{
subcategory = cbSubcategories.SelectedItem as MSubcategory;
subcategoryID = subcategory.SubcategoryID;
if (subcategory.Name == "All subcategories")
{
await LoadList(null);
}
else
{
var request = new CourseSearchRequest()
{
SubcategoryID = subcategoryID
};
await LoadList(request);
}
break;
}
if (userRole.RoleID == 2)
{
subcategory = cbSubcategories.SelectedItem as MSubcategory;
subcategoryID = subcategory.SubcategoryID;
var userID = _user.UserID;
if (subcategory.Name == "All subcategories")
{
var request = new CourseSearchRequest
{
UserID = userID
};
await LoadList(request);
}
else
{
var request = new CourseSearchRequest()
{
SubcategoryID = subcategoryID,
UserID = userID
};
await LoadList(request);
}
}
}
}
public async Task CourseSearchAsyncReturnsResponseObjectWhenApiCallIsSuccessful()
{
// Arrange
var courseSearchRequest = new CourseSearchRequest {
SubjectKeyword = "Somekeyword"
};
var expectedResponse = new CourseSearchResponse
{
Results = new List <Result>
{
new Result
{
CourseId = courseId,
CourseRunId = courseRunId,
CourseName = "CourseName",
},
},
};
var httpResponse = new HttpResponseMessage {
StatusCode = HttpStatusCode.OK, Content = new StringContent(JsonConvert.SerializeObject(expectedResponse))
};
var fakeHttpRequestSender = A.Fake <IFakeHttpRequestSender>();
A.CallTo(() => fakeHttpRequestSender.Send(A <HttpRequestMessage> .Ignored)).Returns(httpResponse);
var auditService = A.Fake <IAuditService>();
var fakeHttpMessageHandler = new FakeHttpMessageHandler(fakeHttpRequestSender);
var httpClient = new HttpClient(fakeHttpMessageHandler)
{
BaseAddress = new Uri("http://SomeDummyUrl")
};
var findACourseClient = new FindACourseClient(httpClient, defaultSettings, auditService, defaultLogger);
// Act
var result = await findACourseClient.CourseSearchAsync(courseSearchRequest).ConfigureAwait(false);
// Assert
Assert.NotNull(result);
Assert.Equal(expectedResponse.Results.FirstOrDefault()?.CourseName, result.Results?.FirstOrDefault()?.CourseName);
Assert.Equal(expectedResponse.Results?.FirstOrDefault()?.CourseRunId, result.Results?.FirstOrDefault()?.CourseRunId);
Assert.Equal(expectedResponse.Results?.FirstOrDefault()?.CourseId, result.Results?.FirstOrDefault()?.CourseId);
httpResponse.Dispose();
httpClient.Dispose();
fakeHttpMessageHandler.Dispose();
}
private async void btnSearch_Click(object sender, EventArgs e)
{
var search = txtSearch.Text;
if (search.StartsWith("Enter"))
{
search = "";
}
var request = new CourseSearchRequest()
{
Name = search
};
await LoadList(request);
}
public async Task <List <MCourse> > GetLikedCourse(int ID, CourseSearchRequest request)
{
var query = _context.UserLikedCourses
.Include(i => i.Course)
.ThenInclude(i => i.User)
.Where(i => i.UserID == ID)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(request?.Name))
{
query = query.Where(x => x.Course.Name.StartsWith(request.Name));
}
var list = await query.ToListAsync();
return(_mapper.Map <List <MCourse> >(list.Select(i => i.Course).ToList()));
}
public async Task <CoursesResponse> GetAsync(
[FromQuery] CourseSearchRequest request,
CancellationToken token)
{
_userManager.TryGetLongUserId(User, out var userId);
IEnumerable <CourseDto> temp;
if (!string.IsNullOrEmpty(request.Term))
{
var query = new CourseSearchWithTermQuery(userId, request.Term, request.Page);
temp = await _queryBus.QueryAsync(query, token);
}
else
{
var query = new CourseSearchQuery(userId, request.Page);
temp = await _queryBus.QueryAsync(query, token);
}
return(new CoursesResponse
{
Courses = temp
});
}
public async Task <PagedList <CourseDto> > GetPagedAsync(Guid authorId, CourseSearchRequest request)
{
if (authorId == Guid.Empty)
{
throw new ArgumentNullException(nameof(authorId));
}
if (!AuthorExists(authorId))
{
return(null);
}
var query = _context.Courses.AsNoTracking()
.Where(c => c.AuthorId == authorId)
.AsQueryable();
query = ApplyFilter(query, request);
List <CourseDto> list = await query.Select(x => x.ToDto())
.ToListAsync();
return(new PagedList <CourseDto>(list));
}
private async void cbSubcategories_SelectedIndexChanged(object sender, EventArgs e)
{
var subcategory = cbSubcategories.SelectedItem as MSubcategory;
var subcategoryID = subcategory.SubcategoryID;
var userID = _user.UserID;
if (subcategory.Name == "All subcategories")
{
var request = new CourseSearchRequest
{
UserID = userID
};
await LoadList(request);
}
else
{
var request = new CourseSearchRequest()
{
SubcategoryID = subcategoryID,
UserID = userID
};
await LoadList(request);
}
}
public async Task <ActionResult <PagedList <CourseDto> > > GetCoursesForAuthor(Guid authorId, [FromQuery] CourseSearchRequest request)
{
var courses = await _coursesService.GetPagedAsync(authorId, request);
if (courses == null)
{
return(NotFound());
}
return(Ok(courses));
}
public async Task <List <MCourse> > GetLikedCourse(int ID, [FromQuery] CourseSearchRequest request)
{
return(await _service.GetLikedCourse(ID, request));
}
public async Task InitLectures()
{
Rating = await courseService.GetAverageRating <float>(Course.CourseID);
Total = await courseService.GetTotalStudents <int>(Course.CourseID);
videoLectureList.Clear();
try
{
var lectures = await courseService.GetLectures <List <MVideoLecture> >(Course.CourseID, null);
if (lectures.Count() != 0)
{
foreach (var lecture in lectures)
{
videoLectureList.Add(lecture);
var req = new SectionSearchRequest
{
SectionID = lecture.SectionID
};
var sections = await sectionService.Get <List <MSection> >(req);
foreach (var section in sections)
{
if (lecture.SectionID == section.SectionID)
{
sectionList.Add(section);
}
}
}
foreach (var x in sectionList)
{
var DoesItContain = NewsectionList.Where(m => m.SectionID == x.SectionID).Any();
if (DoesItContain == false)
{
NewsectionList.Add(x);
}
}
}
CourseSearchRequest request = new CourseSearchRequest()
{
UserID = Course.User.UserID
};
InstructorList.Clear();
var courses = await courseService.Get <List <MCourse> >(request);
foreach (var course in courses)
{
if (courses.Count > 0)
{
if (course.CourseID != Course.CourseID)
{
InstructorList.Add(new CourseVM(course));
}
}
else
{
InstructorList.Add(new CourseVM(course));
}
}
}
catch (Exception)
{
}
}
private IQueryable <CourseEntity> ApplyFilter(IQueryable <CourseEntity> query, CourseSearchRequest request)
{
if (!string.IsNullOrEmpty(request.Term))
{
query = query.Where(x => x.Title.ToLower().Contains(request.Term.Trim().ToLower()) ||
x.Description.ToLower().Contains(request.Term.Trim().ToLower()));
}
return(query);
}
public async Task <ActionResult> CourseSearch([FromBody] CourseSearchRequest request)
{
var criteria = new SearchCriteriaStructure()
{
AttendancePatterns = request.AttendancePatterns,
DeliveryModes = request.DeliveryModes,
Distance = request.Distance,
Limit = request.Limit,
Postcode = request.Postcode,
ProviderName = request.ProviderName,
QualificationLevels = request.QualificationLevels,
SortBy = request.SortBy,
Start = request.Start,
StartDateFrom = request.StartDateFrom,
StartDateTo = request.StartDateTo,
StudyModes = request.StudyModes,
SubjectKeyword = request.SubjectKeyword,
Town = request.Town
};
var result = await _service.CourseSearch(_log, criteria);
var response = new CourseSearchResponse()
{
Limit = result.Limit,
Start = result.Start,
Total = result.Total,
Facets = result.Facets.ToDictionary(
f => _courseSearchFacetMapping.GetValueOrDefault(f.Key, f.Key),
f => f.Value.Select(v => new FacetCountResult()
{
Value = v.Value,
Count = v.Count.Value
})),
Results = result.Items.Select(i => new CourseSearchResponseItem()
{
Cost = i.Course.Cost,
CostDescription = i.Course.CostDescription,
CourseDescription = i.Course.CourseDescription,
CourseName = i.Course.CourseName,
CourseId = i.Course.CourseId,
CourseRunId = i.Course.CourseRunId,
CourseText = i.Course.CourseText,
DeliveryMode = i.Course.DeliveryMode,
DeliveryModeDescription = i.Course.DeliveryModeDescription,
Distance = !i.Course.National.GetValueOrDefault() ? i.Distance : null,
DurationUnit = i.Course.DurationUnit ?? DurationUnit.Undefined,
DurationValue = i.Course.DurationValue,
FlexibleStartDate = i.Course.FlexibleStartDate,
LearnAimRef = i.Course.LearnAimRef,
National = i.Course.National,
QualificationLevel = i.Course.NotionalNVQLevelv2,
ProviderName = i.Course.ProviderName,
QualificationCourseTitle = i.Course.QualificationCourseTitle,
Region = i.Course.Region,
SearchScore = i.Score,
StartDate = !i.Course.FlexibleStartDate.GetValueOrDefault() ? i.Course.StartDate : null,
UKPRN = i.Course.UKPRN,
UpdatedOn = i.Course.UpdatedOn,
VenueAddress = i.Course.VenueAddress,
VenueAttendancePattern = i.Course.VenueAttendancePattern,
VenueAttendancePatternDescription = i.Course.VenueAttendancePatternDescription,
VenueLocation = i.Course.VenueLocation != null ?
new Coordinates()
{
Latitude = i.Course.VenueLocation.Latitude,
Longitude = i.Course.VenueLocation.Longitude
} :
null,
VenueName = i.Course.VenueName,
VenueStudyMode = i.Course.VenueStudyMode,
VenueStudyModeDescription = i.Course.VenueStudyModeDescription,
VenueTown = i.Course.VenueTown
}).ToList()
};
return(new OkObjectResult(response));
}
