private void button1_Click(object sender, EventArgs e)
{
var filter = new AnimalFilter();
var confd = new ConfidenceCheck();
List <Tag> tags = animalImageTagger.GetTagsForImage(textBox1.Text);
foreach (Tag tag in tags)
{
//checking each picutre
filter.checkAnimal(tag.name, tag.confidence);
if (confd.result(tag.confidence) == true)
{
if (tag.name == "dog")
{
checkBox1.Checked = true;
}
else if (tag.name == "cat")
{
checkBox2.Checked = true;
}
else if (tag.name == "bird")
{
checkBox3.Checked = true;
}
}
pictureBox1.Image = Image.FromFile(@"" + textBox1.Text);
}
}
public async Task <IEnumerable <Stay> > HandleFilter(AnimalFilter filter)
{
IEnumerable <Stay> stayList = new List <Stay>();
using (var httpClient = new HttpClient())
{
var builder = new UriBuilder(apiBaseUrl + "/api/stay");
var query = HttpUtility.ParseQueryString(builder.Query);
query["AnimalType"] = filter.AnimalType.ToString();
query["ChildFriendly"] = filter.ChildFriendly.ToString();
query["Gender"] = filter.Gender.ToString();
query["CanBeAdopted"] = true.ToString();
builder.Query = query.ToString();
string url = builder.ToString();
using (var response = await httpClient.GetAsync(url))
{
string apiResponse = await response.Content.ReadAsStringAsync();
stayList = JsonConvert.DeserializeObject <List <Stay> >(apiResponse);
}
return(stayList);
}
}
public Pagination <AnimalDto> GetAllAnimals(AnimalFilter filter = null, AnimalPaginationFilter pagination = null)
{
var filterQuery = _mapper.Map <AnimalQuery>(filter);
var paginationQuery = _mapper.Map <AnimalPaginationQuery>(pagination);
var skip = (paginationQuery.PageNumber - 1) * paginationQuery.PageSize;
IQueryable <Animal> animals = _repository.GetAllQueryable()
.Where(x => x.Status != AnimalStatus.Adopted && !x.IsHidden)
.Include(animal => animal.Images)
.Include(x => x.Category)
.Include(x => x.Videos)
.Include(x => x.Description)
.Include(x => x.Breed)
.OrderByDescending(x => x.IsNew).ThenByDescending(x => x.FoundDate);
if (filter != null)
{
animals = _animalFilterService.AddAllFiltersQuery(filterQuery, animals);
}
var queryResult = animals.ToList();
var animalsResult = animals.Select(x => _mapper.Map <AnimalDto>(x))
.Skip(skip).Take(paginationQuery.PageSize).ToList();
var paginationResponse = PaginationHelper.CreatePaginatedResponse(_uriService, paginationQuery,
animalsResult, queryResult, "/Animal/GetAllAnimalsIncludeValues", filterQuery);
return(paginationResponse);
}
public void FilterByEmptyConditions()
{
AnimalFilter animalFilter = new AnimalFilter();
IEnumerable <Animal> animals = controller.Get(animalFilter);
Assert.Equal(8, animals.Count());
}
public async Task <IActionResult> IndexAsync([FromQuery] AnimalFilter animalFilters)
{
var vm = new StayViewModel();
vm.Stays = await _stayRepository.HandleFilter(animalFilters);
return(View(vm));
}
public void FilterByStrainTest()
{
AnimalFilter animalFilter = new AnimalFilter();
animalFilter.Strain = "kot";
IEnumerable <Animal> animals = controller.Get(animalFilter);
Assert.Equal(2, animals.Count());
}
public void FilterByAgeAndSizeTest()
{
AnimalFilter animalFilter = new AnimalFilter();
animalFilter.Size = 2;
animalFilter.Age = 4;
IEnumerable <Animal> animals = controller.Get(animalFilter);
Assert.Equal(1, animals.Count());
}
public void FilterByWeightAndStrain()
{
AnimalFilter animalFilter = new AnimalFilter();
animalFilter.Strain = "papuga";
animalFilter.Weight = 50;
IEnumerable <Animal> animals = controller.Get(animalFilter);
Assert.Equal(0, animals.Count());
}
public IEnumerable <Stay> GetAllWithFilter(AnimalFilter filter = null)
{
var stayList = _stayRepository.GetStayWithAnimal();
if (filter == null)
{
return(stayList.ToList());
}
else
{
return(AddFilters(filter, stayList));
}
}
public IEnumerable <Animal> Get([FromQuery] AnimalFilter filter) //returns list of all animals (filtering and sorting is avaliable)
{
IEnumerable <Animal> animals = _context.Animal;
if (filter != null && filter.ParametersExist())
{
animals = filter.FilterAnimals(animals);
}
if (filter != null && filter.OrderParameterExist())
{
animals = filter.SortAnimals(animals);
}
return(animals);
}
public void SortBySizeAscending()
{
bool compareSize = true;
AnimalFilter animalFilter = new AnimalFilter();
animalFilter.OrderBy = "Size";
IEnumerable <Animal> animals = controller.Get(animalFilter);
for (int i = 0; i < animals.Count() - 1; i++)
{
compareSize = (animals.ElementAt(i).Size <= animals.ElementAt(i + 1).Size);
}
Assert.True(compareSize);
}
public ActionResult <Pagination <IEnumerable <AnimalDto> > > Get([FromQuery] AnimalFilter getAllAnimalPostFilter = null
, [FromQuery] AnimalPaginationFilter pagination = null)
{
try
{
var animals = _animalService.GetAllAnimals(getAllAnimalPostFilter, pagination);
return(Ok(animals));
}
catch (Exception ex)
{
//log error
return(BadRequest(ex.Message));
}
}
public void SortByDateDescending()
{
bool compareDate = true;
AnimalFilter animalFilter = new AnimalFilter();
animalFilter.OrderBy = "Added desc";
IEnumerable <Animal> animals = controller.Get(animalFilter);
for (int i = 0; i < animals.Count() - 1; i++)
{
compareDate = (DateTime.Compare(animals.ElementAt(i).Added, animals.ElementAt(i + 1).Added) >= 0);
}
Assert.True(compareDate);
}
public void GetQueryString_returns_correct_filter()
{
var filter = new AnimalFilter()
{
Breed = "apple",
Distance = 1,
Location = 2,
};
var expected = $"{mockOptions.Object.Value.PetFinderAnimalUrl}?location=2&distance=1&breed=apple";
var result = petFinderService.GetQueryString(filter);
Assert.AreEqual(expected, result);
}
public async Task <IActionResult> Filter(StayViewModel stay)
{
var vm = new StayViewModel();
AnimalFilter filter = new AnimalFilter
{
Gender = stay.Animal.Gender,
AnimalType = stay.Animal.AnimalType,
ChildFriendly = stay.Animal.ChildFriendly,
CanBeAdopted = true
};
vm.Stays = await _stayRepository.HandleFilter(filter);
return(View("Views/Stay/Index.cshtml", vm));
}
public IActionResult AnimalPagedList([FromQuery] AnimalFilter filter)
{
try
{
var result = new PagingResultViewModel <AnimalListViewModel>();
var pagingAnimals = _animalService.GetAnimals(filter.Page.Value, filter.PageSize.Value, filter.AnimalStatus, filter.Search, filter.IsActive);
if (pagingAnimals.Elements.Any())
{
var animalsListViewModel = pagingAnimals.Elements.Select(animal => new AnimalListViewModel()
{
Id = animal.Id,
Name = animal.Name,
Age = animal.Age,
AnimalType = animal.AnimalType.GetDescription(),
Behavior = animal.Behavior,
Breed = animal.Breed,
Status = animal.Status,
AdopterName = animal.Adopter?.Name,
PictureUrl = animal.PictureUrl
});
result = new PagingResultViewModel <AnimalListViewModel>(filter.Page.Value, filter.PageSize.Value)
{
Elements = animalsListViewModel,
ElementsCount = pagingAnimals.ElementsCount
};
}
else
{
return(RequestResponse(HttpStatusCode.NotFound, "hipets/api/v1/animals", result: "No content"));
}
return(IsAValidOperation()
? RequestResponse(HttpStatusCode.OK, result: result)
: RequestResponse(HttpStatusCode.NotFound, "hipets/api/v1/animals", isError: true));
}
catch (Exception ex)
{
var error = JsonConvert.SerializeObject(ex);
_logger.LogError(error);
return(RequestResponse(HttpStatusCode.BadRequest, isError: true, result: "Ocorreu um erro ao listar os animais"));
}
}
public IEnumerable <Animal> GetByStrain(string strain, [FromQuery] AnimalFilter filter) //returns animal with specific strain (filtering and sorting is avaliable)
{
IEnumerable <Animal> animals = Enumerable.Empty <Animal>();;
if (!String.IsNullOrEmpty(strain))
{
animals = _context.Animal.Where(a => a.Strain.Equals(strain));
}
if (filter != null && filter.ParametersExist())
{
animals = filter.FilterAnimals(animals);
}
if (filter != null && filter.OrderParameterExist())
{
animals = filter.SortAnimals(animals);
}
return(animals);
}
public async Task <AnimalResult> GetPets(AnimalFilter filters)
{
var result = new AnimalResult();
var filter = GetQueryString(filters);
var response = await Get(filter);
if (response.IsSuccessStatusCode)
{
var data = await response.Content.ReadAsStringAsync();
result = JsonConvert.DeserializeObject <AnimalResult>(data);
}
else
{
throw new Exception(response.ReasonPhrase);
}
return(result);
}
public string GetQueryString(AnimalFilter filters)
{
if (filters == null)
{
return(settings.Value.PetFinderAnimalUrl);
}
List <string> parameters = new List <string>();
foreach (var property in filters.GetType().GetProperties())
{
if (property.GetValue(filters) != null)
{
parameters.Add($"{property.Name.ToLower()}={property.GetValue(filters)}");
}
}
var queryUrl = $"{settings.Value.PetFinderAnimalUrl}?{string.Join('&', parameters.ToArray())}";
return(queryUrl);
}
// TODO: Clean this function up if possible
private IEnumerable <Stay> AddFilters(AnimalFilter filter, IEnumerable <Stay> stays)
{
// Filter will only work on animals that can actually be adopted; others should not show up
stays = stays.Where(x => x.CanBeAdopted == true);
if (filter.AnimalType != null)
{
stays = stays.Where(x => x.Animal.AnimalType == filter.AnimalType);
}
if (filter.ChildFriendly != null)
{
stays = stays.Where(x => x.Animal.ChildFriendly == filter.ChildFriendly);
}
if (filter.Gender != null)
{
stays = stays.Where(x => x.Animal.Gender == filter.Gender);
}
return(stays.ToList());
}
static void Main(string[] args)
{
List <IAnimal> animals = new List <IAnimal>
{
new Mamifero {
Name = "Tigre", Order = AnimalOrder.Carnivoro
},
new Mamifero {
Name = "Chimpancé", Order = AnimalOrder.Omnivoro
},
new Ave {
Name = "Aguila", Order = AnimalOrder.Carnivoro
},
new Ave {
Name = "Condor", Order = AnimalOrder.Carnivoro
},
new Pez {
Name = "Pez globo", Order = AnimalOrder.Carnivoro
},
new Mamifero {
Name = "Vaca", Order = AnimalOrder.Herbivoro
},
new Mamifero {
Name = "Oveja", Order = AnimalOrder.Herbivoro
}
};
animals.ForEach(animal => Console.WriteLine(animal.ToString()));
Console.WriteLine("Aves:");
var birds = new AnimalFilter().FilterByClass(animals, AnimalClass.Aves);
birds.ForEach(bird => Console.WriteLine(bird.ToString()));
Console.ReadLine();
}
public IActionResult Index([FromQuery] AnimalFilter animalFilters)
{
var animalList = _stayService.GetAllWithFilter(animalFilters);
return(Ok(animalList.ToList()));
}
