public async Task <ICollection <Doctor> > GetDoctorAsync(
DoctorsFilter filter = null,
PaginationFilter pagination = null)
{
if (pagination != null && filter != null)
{
return(await _repositoryWrapper.DoctorRepository.GetAsync(filter : Filter(filter),
include : c => c.Include(i => i.User)
.Include(d => d.Position),
pageNumber : pagination.PageNumber, pageSize : pagination.PageSize));
}
if (filter != null)
{
return(await _repositoryWrapper.DoctorRepository.GetAsync(filter : Filter(filter),
include : c => c.Include(i => i.User)
.Include(d => d.Position)));
}
if (pagination != null)
{
return(await _repositoryWrapper.DoctorRepository.GetAsync(
include : c => c.Include(i => i.User)
.Include(d => d.Position),
pageNumber : pagination.PageNumber, pageSize : pagination.PageSize));
}
var doctors = await _repositoryWrapper.DoctorRepository.GetAsync(
include : c => c.Include(i => i.User)
.Include(d => d.Position));
return(doctors);
}
public async Task GetAll_Doctors_ReturnsTrue(
[Frozen] List <Doctor> doctor,
[Frozen] List <ReadDoctorDto> doctorDto,
[Frozen] PaginationQuery paginationQuery,
[Frozen] PaginationFilter paginationFilter,
[Frozen] DoctorsFiltrationQuery query,
[Frozen] DoctorsFilter filter
)
{
// Arrange
doctorServiceMock.Setup(m => m.GetDoctorAsync(filter, paginationFilter))
.ReturnsAsync(doctor);
mapper.Setup(m => m.Map <ICollection <ReadDoctorDto> >(doctor))
.Returns(doctorDto);
mapper.Setup(m => m.Map <PaginationFilter>(paginationQuery))
.Returns(paginationFilter);
mapper.Setup(m => m.Map <DoctorsFilter>(query))
.Returns(filter);
// Act
var actualResult = await doctorController.GetAsync(query, paginationQuery);
// Assert
var result = actualResult as OkObjectResult;
Assert.True(actualResult is OkObjectResult);
doctorServiceMock.Verify(m => m.GetDoctorAsync(filter, paginationFilter), Times.Once);
}
private static Expression <Func <Doctor, bool> > Filter(DoctorsFilter filter)
{
var expressionsList = new List <Expression <Func <Doctor, bool> > >();
if (filter.PositionId != null)
{
Expression <Func <Doctor, bool> > positionFilter = a => a.PositionId == filter.PositionId;
expressionsList.Add(positionFilter);
}
if (filter.UserId != null)
{
Expression <Func <Doctor, bool> > userFilter = a => a.UserId == filter.UserId;
expressionsList.Add(userFilter);
}
if (filter.IsDeleted != null)
{
Expression <Func <Doctor, bool> > userFilter = a => a.User.IsDeleted == filter.IsDeleted.Value;
expressionsList.Add(userFilter);
}
if (filter.IsDeleted == null)
{
Expression <Func <Doctor, bool> > userFilter = a => !a.User.IsDeleted;
expressionsList.Add(userFilter);
}
if (filter.Name != null)
{
Expression <Func <Doctor, bool> > nameFilter = a => a.User.FirstName.ToUpper().StartsWith(filter.Name.ToUpper()) ||
a.User.LastName.ToUpper().StartsWith(filter.Name.ToUpper()) ||
(a.User.FirstName.ToUpper() + " " + a.User.LastName.ToUpper()).StartsWith(filter.Name.ToUpper()) ||
(a.User.LastName.ToUpper() + " " + a.User.FirstName.ToUpper()).StartsWith(filter.Name.ToUpper());
expressionsList.Add(nameFilter);
}
Expression <Func <Doctor, bool> > expression = doctor => true;
foreach (var exp in expressionsList)
{
expression = expression.AndAlso(exp);
}
return(expression);
}
public async Task GetTotalCount_EqualCount([Frozen] List <Doctor> doctors,
DoctorsFilter filter,
[Frozen] Mock <IUserService> _userServiceMock,
[Frozen] Mock <IRepositoryWrapper> _repositoryMock,
[Frozen] Mock <RoleManager <IdentityRole> > _roleManagerMock)
{
// Arrange
_repositoryMock.Setup(x => x.DoctorRepository
.CountAsync(It.IsAny <Expression <Func <Doctor, bool> > >()))
.ReturnsAsync(doctors.Count);
var _doctorService = new DoctorService(_repositoryMock.Object, _userServiceMock.Object, _roleManagerMock.Object);
// Act
var actual = await _doctorService.GetTotalCount(filter);
// Assert
Assert.Equal(doctors.Count, actual);
_repositoryMock.Verify(m => m.DoctorRepository
.CountAsync(It.IsAny <Expression <Func <Doctor, bool> > >()),
Times.Once);
}
public IActionResult Index(DoctorsFilter filter = null)
{
try
{
var doctors = _doctorsRepository.getQueryable();
if (!string.IsNullOrWhiteSpace(filter.title))
{
doctors = doctors.Where(a => a.name.Contains(filter.title));
}
ViewBag.pagerInfo = _paginatedMetaService.GetMetaData(doctors.Count(), filter.page, filter.number_of_rows);
doctors = doctors.Skip(filter.number_of_rows * (filter.page - 1)).Take(filter.number_of_rows);
return(View(doctors.OrderByDescending(a => a.doctor_id).ToList()));
}
catch (Exception ex)
{
AlertHelper.setMessage(this, ex.Message, messageType.error);
return(Redirect("/admin"));
}
}
public async Task <int> GetTotalCount(DoctorsFilter filter = null)
{
return(await _repositoryWrapper.DoctorRepository.CountAsync(Filter(filter)));
}
