private async Task HandleCategoryCounters(PersonCategoryFilter filter)
{
var personCategory = await FindGategory(filter);
DecrementCategoryCounters(filter, personCategory);
await PersonCategoryRepository.Save(Transaction, personCategory);
}
private async Task <PersonCategoryCounter> FindGategory(PersonCategoryFilter filter)
{
var categories = await PersonCategoryRepository.GetPersonCategoryCounters(Anonimize(filter));
var personCategory = categories[0];
return(personCategory);
}
private async Task HandleCityCounters(PersonDTO person, PersonCategoryFilter filter)
{
var city = person.Address.City;
var personPerCityCategory = await PersonPerCityCounterRepository.GetByCity(city);
DecrementPerCityCounters(filter, personPerCityCategory);
await PersonPerCityCounterRepository.Save(Transaction, personPerCityCategory);
}
private static FilterDefinition <PersonCategoryCounter> CreateFilterFromCategoryFilter(
PersonCategoryFilter personCategoryFilter, FilterDefinition <PersonCategoryCounter> filter)
{
filter = AddNameFilter(personCategoryFilter, filter);
filter = AddEqFilter(x => x.Race, personCategoryFilter.Race, filter);
filter = AddEqFilter(x => x.Sex, personCategoryFilter.Sex, filter);
filter = AddEqFilter(x => x.SchoolLevel, personCategoryFilter.SchoolLevel, filter);
return(filter);
}
protected static PersonCategoryFilter Anonimize(PersonCategoryFilter filter)
{
return(new PersonCategoryFilter()
{
Name = string.Empty,
Race = filter.Race,
SchoolLevel = filter.SchoolLevel,
Sex = filter.Sex
});
}
public async Task <List <PersonCategoryCounter> > GetPersonCategoryCounters(PersonCategoryFilter personCategoryFilter)
{
var collection = MongoConnection.GetPersonCategoriesCollection();
var filter = Builders <PersonCategoryCounter> .Filter.Empty;
filter = CreateFilterFromCategoryFilter(personCategoryFilter, filter);
var result = await collection.FindAsync(filter);
var list = result.ToList();
CreateDefaultResult(list, personCategoryFilter);
return(list);
}
private static FilterDefinition <PersonCategoryCounter> AddNameFilter(PersonCategoryFilter personCategoryFilter,
FilterDefinition <PersonCategoryCounter> filter)
{
if (!String.IsNullOrEmpty(personCategoryFilter.Name))
{
var nameFilter = Builders <PersonCategoryCounter>
.Filter.Where(x => x.PersonNameCounters.ContainsKey(personCategoryFilter.Name));
filter &= nameFilter;
}
return(filter);
}
private async Task HandleCategoryCounters(PersonCategoryFilter oldFilter,
PersonCategoryFilter newFilter)
{
var oldPersonCategory = await FindGategory(oldFilter);
DecrementCategoryCounters(oldFilter, oldPersonCategory);
await PersonCategoryRepository.Save(Transaction, oldPersonCategory);
var newPersonCategory = await FindGategory(newFilter);
IncrementCategoryCounters(newFilter, newPersonCategory);
await PersonCategoryRepository.Save(Transaction, newPersonCategory);
}
private static void CreateDefaultResult(List <PersonCategoryCounter> list,
PersonCategoryFilter personCategoryFilter)
{
if (list.Count == 0)
{
list.Add(new PersonCategoryCounter()
{
Count = 0,
Race = personCategoryFilter.Race,
SchoolLevel = personCategoryFilter.SchoolLevel,
Sex = personCategoryFilter.Sex
});
}
}
private async Task HandleCityCounters(string oldCity, string newCity,
PersonCategoryFilter oldFilter, PersonCategoryFilter newFilter)
{
if (oldCity != newCity)
{
var oldPersonPerCityCategory = await PersonPerCityCounterRepository.GetByCity(oldCity);
DecrementPerCityCounters(oldFilter, oldPersonPerCityCategory);
await PersonPerCityCounterRepository.Save(Transaction, oldPersonPerCityCategory);
var newPersonPerCityCategory = await PersonPerCityCounterRepository.GetByCity(newCity);
IncrementPerCityCounters(newFilter, newPersonPerCityCategory);
await PersonPerCityCounterRepository.Save(Transaction, newPersonPerCityCategory);
}
}
public async Task <ActionResult <List <PersonCategoryCounter> > > Get([FromQuery] string name,
[FromQuery] string sex,
[FromQuery] string education,
[FromQuery] string race)
{
var filter = new PersonCategoryFilter()
{
Name = name, Sex = sex, SchoolLevel = education, Race = race
};
var result = await Mediator.Send(new PersonCategoryQuery()
{
PersonCategoryFilter = filter
});
return(Ok(result));
}
protected static void AlterNameCounters(PersonCategoryFilter filter,
Dictionary <string, PersonNameCounter> nameCounters, int delta, int initial)
{
if (nameCounters.ContainsKey(filter.Name))
{
nameCounters[filter.Name].Count =
Math.Max(nameCounters[filter.Name].Count + delta, 0);
}
else
{
nameCounters[filter.Name] = new PersonNameCounter()
{
Name = filter.Name,
Count = initial,
};
}
}
protected static void IncrementCategoryCounters(PersonCategoryFilter filter,
PersonCategoryCounter personCategory)
{
personCategory.Count++;
IncrementNameCounters(filter, personCategory.PersonNameCounters);
}
protected static void DecrementNameCounters(PersonCategoryFilter filter,
Dictionary <string, PersonNameCounter> nameCounters)
{
AlterNameCounters(filter, nameCounters, -1, 0);
}
protected static void DecrementPerCityCounters(PersonCategoryFilter filter,
PersonPerCityCounter personCategory)
{
personCategory.Count = Math.Max(personCategory.Count - 1, 0);
DecrementNameCounters(filter, personCategory.PersonNameCounters);
}
