public async override Task <CommonResponseMessage> GetClinics(CommonRequestMessage request, ServerCallContext context)
{
var result = new CommonResponseMessage();
var dto = JsonConvert.DeserializeObject <PaginationRequestDto>(request.Content);
var query = await clinicRepository.GetAll();
var totalItem = query.Count();
var property = typeof(Clinic).GetProperties().Where(p => p.CanWrite && p.Name.ToLower() == dto.Column?.ToLower()).SingleOrDefault();
switch (dto.Type)
{
case PaginationType.Sorting:
query = dto.IsAscending ? query.OrderBy(c => property.GetValue(c)) : query.OrderByDescending(c => property.GetValue(c));
break;
case PaginationType.Searching:
query = query.Where(c => c.Name != null && c.Name.ToLower().Contains(dto.SearchText?.ToLower()));
break;
default:
break;
}
query = query.Skip(dto.Page * dto.PageItemCount).Take(dto.PageItemCount);
var clinics = query?.ToClinicItemDtoList();
var paginatedList = new Paginatedlist <ClinicItemDto>(clinics, dto.Page, totalItem, dto.PageItemCount);
return(new CommonResponseMessage {
Content = JsonConvert.SerializeObject(paginatedList), Message = "Success", Status = true
});
}
public async Task UpdateEquipment_DataDrivenTest(EquipmentUpdateDto model, bool expectation)
{
try
{
var equipmentId = Context.Equipments.First()?.Id;
model.Id = equipmentId.Value;
var requestModel = new CommonRequestMessage {
Content = JsonConvert.SerializeObject(model)
};
CommonResponseMessage response = await sut.UpdateEquipment(requestModel, default(ServerCallContext));
var equipment = JsonConvert.DeserializeObject <EquipmentDetailDto>(response.Content);
if (expectation)
{
Assert.True(response.Status);
Assert.Equal(equipment.Id, model.Id);
}
else
{
Assert.False(response.Status);
}
}
catch
{
Assert.True(false);
}
}
public async override Task <CommonResponseMessage> UpdateEquipment(CommonRequestMessage request, ServerCallContext context)
{
var dto = JsonConvert.DeserializeObject <EquipmentUpdateDto>(request.Content);
if (!await clinicRepository.Any(dto.ClinicId))
{
return(new CommonResponseMessage {
Content = "", Message = $"There is no clinic with id : {dto.ClinicId}", Status = false
});
}
var equipment = await equipmentRepository.Get(dto.Id);
if (equipment == null)
{
return new CommonResponseMessage {
Content = "", Message = "Unable to find equipment to update", Status = false
}
}
;
equipment.Parse(dto);
await equipmentRepository.SaveChangesAsync();
var result = equipment.ToEquipmentDetailDto();
return(new CommonResponseMessage {
Content = JsonConvert.SerializeObject(result), Message = "Success", Status = true
});
}
public async override Task <CommonResponseMessage> GetEquipments(CommonRequestMessage request, ServerCallContext context)
{
var dto = JsonConvert.DeserializeObject <EquipmentPaginationRequestDto>(request.Content);
var query = await equipmentRepository.GetAllIncludeAll();
if (dto.ClinicId > 0)
{
query = query.Where(c => c.ClinicId == dto.ClinicId);
}
var totalItem = query.Count();
query = SortAndFilterEquipments(dto, query);
query = query.Skip(dto.Page * dto.PageItemCount)
.Take(dto.PageItemCount);
var equipments = query?.ToEquipmentItemDtoList();
var result = new Paginatedlist <EquipmentItemDto>(equipments, dto.Page, totalItem, dto.PageItemCount);
return(new CommonResponseMessage {
Content = JsonConvert.SerializeObject(result), Message = "Success", Status = true
});
}
public async override Task <CommonResponseMessage> GetEquipment(CommonRequestMessage request, ServerCallContext context)
{
var equipmentId = JsonConvert.DeserializeObject <int>(request.Content);
var equipment = (await equipmentRepository.Get(equipmentId))?.ToEquipmentDetailDto();
var result = new CommonResponseMessage {
Content = JsonConvert.SerializeObject(equipment), Message = "Success", Status = true
};
return(result);
}
public async Task GetEquipment_ReturnsNull_When_IdAbsent()
{
var equipmentId = int.MaxValue;
var requestModel = new CommonRequestMessage {
Content = JsonConvert.SerializeObject(equipmentId)
};
var result = await sut.GetEquipment(requestModel, default(ServerCallContext));
var equipment = JsonConvert.DeserializeObject <EquipmentDetailDto>(result.Content);
Assert.True(result.Status);
Assert.Null(equipment);
}
public async Task DeleteEquipment_IsSuccess()
{
var clinicToClone = equipmentRepository.GetAll().Result.First();
var clinicToInsert = JsonConvert.DeserializeObject <Equipment>(JsonConvert.SerializeObject(clinicToClone));
clinicToInsert.Name = "Equipment to be deleted";
clinicToInsert.Id = 0;
equipmentRepository.Add(clinicToInsert);
equipmentRepository.SaveChanges();
var requestModel = new CommonRequestMessage {
Content = JsonConvert.SerializeObject(clinicToInsert.Id)
};
var result = await sut.DeleteEquipment(requestModel, default(ServerCallContext));
Assert.True(result.Status);
}
public async Task InsertEquipment_DataDrivenTest(EquipmentInsertDto model, bool expectation)
{
var requestModel = new CommonRequestMessage {
Content = JsonConvert.SerializeObject(model)
};
CommonResponseMessage response = await sut.InsertEquipment(requestModel, default(ServerCallContext));
var equipment = JsonConvert.DeserializeObject <EquipmentDetailDto>(response.Content);
if (expectation)
{
Assert.True(response.Status);
Assert.NotNull(equipment);
Assert.Equal(equipment.Name, model.Name);
}
else
{
Assert.Null(equipment);
}
}
public async override Task <CommonResponseMessage> DeleteEquipment(CommonRequestMessage request, ServerCallContext context)
{
var equipmentId = JsonConvert.DeserializeObject <int>(request.Content);
var equipmentToDelete = await equipmentRepository.Get(equipmentId);
if (equipmentToDelete == null)
{
return new CommonResponseMessage {
Content = "", Message = "Fail", Status = false
}
}
;
equipmentRepository.Remove(equipmentToDelete);
await equipmentRepository.SaveChangesAsync();
return(new CommonResponseMessage {
Content = "", Message = "Success", Status = true
});
}
public async override Task <CommonResponseMessage> InsertEquipment(CommonRequestMessage request, ServerCallContext context)
{
var equipmentToInsert = JsonConvert.DeserializeObject <EquipmentInsertDto>(request.Content);
if (!await clinicRepository.Any(equipmentToInsert.ClinicId))
{
return(new CommonResponseMessage {
Content = "", Message = $"There is no clinic with id : {equipmentToInsert.ClinicId}", Status = false
});
}
var equipment = equipmentToInsert.ToEquipment();
equipmentRepository.Add(equipment);
await equipmentRepository.SaveChangesAsync();
var result = equipment.ToEquipmentDetailDto();
return(new CommonResponseMessage {
Content = JsonConvert.SerializeObject(result), Message = "Success", Status = true
});
}
