public override IEnumerable <GetMeterMeasurementsResponse> Handle(GetMeterMeasurementsQuery query)
{
Specification <MeterMeasurement> filter = new CommonSpecification <MeterMeasurement>(x => true);
if (query.Month.HasValue)
{
filter = filter && new CommonSpecification <MeterMeasurement>(x => x.Date.Month == query.Month.Value);
}
if (query.Year.HasValue)
{
filter = filter && new CommonSpecification <MeterMeasurement>(x => x.Date.Year == query.Year.Value);
}
if (query.MeterMeasurementTypeId.HasValue)
{
filter = filter && new CommonSpecification <MeterMeasurement>(x => x.MeterMeasurementTypeId == query.MeterMeasurementTypeId.Value);
}
var filteredMeasurements =
Repository
.Where(filter)
.ToList();
var result = new List <GetMeterMeasurementsResponse>();
var itemProjector = new Projector.ToFlat <MeterMeasurement, GetMeterMeasurementsResponseMeasurement>();
foreach (var measurement in filteredMeasurements)
{
var group = result.FirstOrDefault(x => x.DateMonth == measurement.Date.Month && x.DateYear == measurement.Date.Year);
if (group != null)
{
group.Measurements.Add(itemProjector.Project(measurement));
}
else
{
group = new GetMeterMeasurementsResponse
{
DateMonth = measurement.Date.Month,
DateYear = measurement.Date.Year,
};
group.Measurements.Add(itemProjector.Project(measurement));
result.Add(group);
}
}
result.ForEach(x => x.SortMeasurements());
return(result.OrderBy(x => x.DateYear).ThenBy(x => x.DateMonth));
}
public override IEnumerable <GetPaymentsResponse> Handle(GetPaymentsQuery query)
{
Specification <Payment> filter = new CommonSpecification <Payment>(x => true);
if (query.PaymentTypeId.HasValue)
{
filter = filter && new CommonSpecification <Payment>(x => x.PaymentTypeId == query.PaymentTypeId);
}
if (query.Month.HasValue)
{
filter = filter && new CommonSpecification <Payment>(x => x.Date.HasValue && x.Date.Value.Month == query.Month.Value);
}
if (query.Year.HasValue)
{
filter = filter && new CommonSpecification <Payment>(x => x.Date.HasValue && x.Date.Value.Year == query.Year.Value);
}
if (query.ExactAmount.HasValue)
{
filter = filter && new CommonSpecification <Payment>(x => x.Amount == query.ExactAmount);
}
else
{
if (query.MinAmount.HasValue)
{
filter = filter && new CommonSpecification <Payment>(x => x.Amount >= query.MinAmount.Value);
}
if (query.MaxAmount.HasValue)
{
filter = filter && new CommonSpecification <Payment>(x => x.Amount <= query.MaxAmount.Value);
}
}
return(Repository
.Where(filter, new Projector.ToFlat <Payment, GetPaymentsResponse>()));;
}
public override IEnumerable <GetUserNotificationsQueryResult> Handle(GetUserNotificationsQuery query)
{
Specification <UserNotification> specification = new CommonSpecification <UserNotification>(x => true);
switch (query.NotificationsType)
{
case GetUserNotificationsType.Visible:
specification = new CommonSpecification <UserNotification>(x => !x.IsHidden);
break;
case GetUserNotificationsType.Hidden:
specification = new CommonSpecification <UserNotification>(x => x.IsHidden);
break;
default:
break;
}
return(Repository
.Where(specification, Projector)
.OrderBy(x => x.CreatedAt)
.ToList());
}
public override GetMeasurementStatisticsQueryResponse Handle(GetMeasurementStatisticsQuery query)
{
if (query.From.HasValue && query.To.HasValue && query.From.Value >= query.To.Value)
{
throw new ArgumentException($"{nameof(query.From)} value must be less than {nameof(query.To)}.");
}
Specification <MeterMeasurement> filter = new CommonSpecification <MeterMeasurement>(x => true);
if (query.MeasurementTypeId.HasValue)
{
filter &= new CommonSpecification <MeterMeasurement>(x => x.MeterMeasurementTypeId == query.MeasurementTypeId);
}
if (query.From.HasValue)
{
filter &= new CommonSpecification <MeterMeasurement>(x => x.Date.Date >= query.From.Value.Date);
}
if (query.To.HasValue)
{
filter &= new CommonSpecification <MeterMeasurement>(x => x.Date.Date <= query.To.Value.Date);
}
var measurements =
MeasurementRepository.Where(filter)
.ToList()
.GroupBy(x => x.MeterMeasurementTypeId);
var response = new GetMeasurementStatisticsQueryResponse()
{
From = query.From,
To = query.To
};
foreach (var typeGroup in measurements)
{
var firstItem = typeGroup.FirstOrDefault();
if (firstItem == null)
{
continue;
}
var typeStatisticsItem = new MeasurementTypeStatisticsItem()
{
MeasurementTypeId = typeGroup.Key,
MeasurementTypeName = firstItem.MeasurementType.Name
};
var groupedByYear = typeGroup.GroupBy(x => x.Date.Year).OrderBy(x => x.Key);
foreach (var yearGroup in groupedByYear)
{
var months = MonthNumbers;
if (query.From.HasValue && query.From.Value.Year == yearGroup.Key)
{
if (query.From.Value.Month > 1)
{
months = months.Where(x => x >= query.From.Value.Month);
}
}
else
{
var isFirstYear = groupedByYear.First().Key == yearGroup.Key;
if (isFirstYear)
{
var month = yearGroup.Select(x => x.Date.Month).Min();
if (month > 0 && month < 12)
{
months = months.Where(x => x >= month);
}
}
}
if (query.To.HasValue && query.To.Value.Year == yearGroup.Key)
{
if (query.To.Value.Month < 12)
{
months = months.Where(x => x <= query.To.Value.Month);
}
}
else
{
var isLastYear = groupedByYear.Last().Key == yearGroup.Key;
if (isLastYear)
{
var month = yearGroup.Select(x => x.Date.Month).Max();
if (month > 0 && month < 12)
{
months = months.Where(x => x <= month);
}
}
}
foreach (var monthNumber in months)
{
var item = yearGroup.FirstOrDefault(x => x.Date.Month == monthNumber);
typeStatisticsItem.StatisticsData.Add(new MeasurementStatisticsDataItem
{
Year = yearGroup.Key,
Month = monthNumber,
MeasurementDiff = item?.Diff
});
}
}
response.TypeStatistics.Add(typeStatisticsItem);
}
return(response);
}
