//------------------------------------------------------------------------------------------
private async Task <string> GetFullNameEmployee(ReportPdfDTO dto)
{
var id = HashHelper.DecryptLong(dto.HashIdEmployee);
var employee = await _context.Employee.FindAsync(id);
return($"{employee.FirstName} {employee.SecondName} {employee.Patronymic}");
}
private async Task <IEnumerable <EventEmployeeEntity> > AddAllEvent(ReportPdfDTO dto)
{
var result = new List <EventEmployeeEntity>();
result.AddRange(await GetEvent(dto, TypeEvent.Travel));
result.AddRange(await GetEvent(dto, TypeEvent.Wellness));
result.AddRange(await GetEvent(dto, TypeEvent.Tour));
return(result);
}
private async Task <IEnumerable <GiftEmployeeEntity> > GetGift(ReportPdfDTO dto)
{
var id = HashHelper.DecryptLong(dto.HashIdEmployee);
var result = await _context.GiftEmployees
.Where(x => (x.DateGift >= dto.StartDate && x.DateGift <= dto.EndDate) && x.IdEmployee == id)
.OrderBy(x => x.DateGift)
.ToListAsync();
return(_mapper.Map <IEnumerable <GiftEmployeeEntity> >(result));
}
private async Task <IEnumerable <GiftEmployeeEntity> > GetGift(ReportPdfDTO dto)
{
var id = _hashIdUtilities.DecryptLong(dto.HashEmployeeId);
var result = await _context.GiftEmployees
.Where(x => x.DateGift.Between(dto.StartDate, dto.EndDate) && x.IdEmployee == id)
.OrderBy(x => x.DateGift)
.ToListAsync();
return(_mapperService.Mapper.Map <IEnumerable <GiftEmployeeEntity> >(result));
}
private async Task <IEnumerable <CulturalEmployeeEntity> > GetCultural(ReportPdfDTO dto)
{
var id = HashHelper.DecryptLong(dto.HashIdEmployee);
var result = await _context.CulturalEmployees
.Include(x => x.IdCulturalNavigation)
.Where(x => (x.DateVisit >= dto.StartDate && x.DateVisit <= dto.EndDate) && x.IdEmployee == id)
.OrderBy(x => x.DateVisit)
.ToListAsync();
return(_mapper.Map <IEnumerable <CulturalEmployeeEntity> >(result));
}
private async Task <IEnumerable <CulturalEmployeeEntity> > GetCultural(ReportPdfDTO dto)
{
var id = _hashIdUtilities.DecryptLong(dto.HashEmployeeId);
var result = await _context.CulturalEmployees
.Include(x => x.IdCulturalNavigation)
.Where(x => x.DateVisit.Between(dto.StartDate, dto.EndDate) && x.IdEmployee == id)
.OrderBy(x => x.DateVisit)
.ToListAsync();
return(_mapperService.Mapper.Map <IEnumerable <CulturalEmployeeEntity> >(result));
}
private async Task <IEnumerable <EventEmployeeEntity> > GetEvent(ReportPdfDTO dto, TypeEvent typeEvent)
{
var id = HashHelper.DecryptLong(dto.HashIdEmployee);
var result = await _context.EventEmployees
.Include(x => x.IdEventNavigation)
.Where(x => (x.StartDate >= dto.StartDate && x.StartDate <= dto.EndDate) &&
(x.EndDate >= dto.StartDate && x.EndDate <= dto.EndDate) &&
x.IdEventNavigation.Type == typeEvent &&
x.IdEmployee == id)
.OrderBy(x => x.StartDate)
.ToListAsync();
return(_mapper.Map <IEnumerable <EventEmployeeEntity> >(result));
}
private async Task <IEnumerable <EventEmployeeEntity> > GetEvent(ReportPdfDTO dto, TypeEvent typeEvent)
{
var id = _hashIdUtilities.DecryptLong(dto.HashEmployeeId);
var result = await _context.EventEmployees
.Include(x => x.IdEventNavigation)
.Where(x => x.StartDate.Between(dto.StartDate, dto.EndDate) &&
x.EndDate.Between(dto.StartDate, dto.EndDate) &&
x.IdEventNavigation.Type == typeEvent &&
x.IdEmployee == id)
.OrderBy(x => x.StartDate)
.ToListAsync();
return(_mapperService.Mapper.Map <IEnumerable <EventEmployeeEntity> >(result));
}
//------------------------------------------------------------------------------------------
public async Task <ActualResult <FileDTO> > CreateReport(ReportPdfDTO dto)
{
try
{
var model = await FillModelReport(dto);
var pdf = _reportGeneratorService.Generate(model);
var reportBucketModel = _mapper.Map <ReportPdfBucketModel>(dto);
reportBucketModel.Pdf = _mapper.Map <FileModel>(pdf);
await _pdfBucketService.PutPdfObject(reportBucketModel);
return(new ActualResult <FileDTO> {
Result = _mapper.Map <FileDTO>(pdf)
});
}
catch (Exception exception)
{
return(new ActualResult <FileDTO>(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
//------------------------------------------------------------------------------------------
public async Task <ActualResult <byte[]> > CreateReport(ReportPdfDTO dto)
{
try
{
var model = await FillModelReport(dto);
var validationModel = ValidatePdfModel(model);
if (validationModel)
{
var pdf = _reportGeneratorService.Generate(model);
if (pdf.Length > 0)
{
await _pdfBucketService.PutPdfObject(new ReportPdfBucketModel
{
IdEmployee = _hashIdUtilities.DecryptLong(dto.HashEmployeeId),
EmailUser = dto.EmailUser,
IpUser = dto.IpUser,
TypeReport = (int)model.Type,
DateFrom = model.StartDate,
DateTo = model.EndDate,
Data = pdf
});
return(new ActualResult <byte[]> {
Result = pdf
});
}
return(new ActualResult <byte[]>(Errors.ApplicationError));
}
return(new ActualResult <byte[]>(Errors.NotFound));
}
catch (Exception exception)
{
return(new ActualResult <byte[]>(DescriptionExceptionHelper.GetDescriptionError(exception)));
}
}
//------------------------------------------------------------------------------------------
private async Task <ReportModel> FillModelReport(ReportPdfDTO dto)
{
var model = _mapper.Map <ReportModel>(dto);
model.FullNameEmployee = await GetFullNameEmployee(dto);
switch (dto.TypeReport)
{
case TypeReport.All:
model.MaterialAidEmployees = await GetMaterialAid(dto);
model.AwardEmployees = await GetAward(dto);
model.EventEmployees = await AddAllEvent(dto);
model.CulturalEmployees = await GetCultural(dto);
model.GiftEmployees = await GetGift(dto);
break;
case TypeReport.MaterialAid:
model.MaterialAidEmployees = await GetMaterialAid(dto);
break;
case TypeReport.Award:
model.AwardEmployees = await GetAward(dto);
break;
case TypeReport.Travel:
model.EventEmployees = await GetEvent(dto, TypeEvent.Travel);
break;
case TypeReport.Wellness:
model.EventEmployees = await GetEvent(dto, TypeEvent.Wellness);
break;
case TypeReport.Tour:
model.EventEmployees = await GetEvent(dto, TypeEvent.Tour);
break;
case TypeReport.Cultural:
model.CulturalEmployees = await GetCultural(dto);
break;
case TypeReport.Gift:
model.GiftEmployees = await GetGift(dto);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(model);
}
private async Task <IEnumerable <MaterialIncentivesEmployeeEntity> > GetAward(ReportPdfDTO dto)
{
var id = HashHelper.DecryptLong(dto.HashIdEmployee);
var result = await _context.AwardEmployees
.Include(x => x.IdAwardNavigation)
.Where(x => (x.DateIssue >= dto.StartDate && x.DateIssue <= dto.EndDate) && x.IdEmployee == id)
.OrderBy(x => x.DateIssue)
.ToListAsync();
return(_mapper.Map <IEnumerable <MaterialIncentivesEmployeeEntity> >(result));
}
//------------------------------------------------------------------------------------------
private async Task <ReportModel> FillModelReport(ReportPdfDTO dto)
{
var model = new ReportModel
{
Type = (TradeUnionCommittee.PDF.Service.Enums.TypeReport)dto.Type,
FullNameEmployee = await GetFullNameEmployee(dto),
StartDate = dto.StartDate,
EndDate = dto.EndDate
};
switch (dto.Type)
{
case TypeReport.All:
model.MaterialAidEmployees = await GetMaterialAid(dto);
model.AwardEmployees = await GetAward(dto);
model.EventEmployees = await AddAllEvent(dto);
model.CulturalEmployees = await GetCultural(dto);
model.GiftEmployees = await GetGift(dto);
break;
case TypeReport.MaterialAid:
model.MaterialAidEmployees = await GetMaterialAid(dto);
break;
case TypeReport.Award:
model.AwardEmployees = await GetAward(dto);
break;
case TypeReport.Travel:
model.EventEmployees = await GetEvent(dto, TypeEvent.Travel);
break;
case TypeReport.Wellness:
model.EventEmployees = await GetEvent(dto, TypeEvent.Wellness);
break;
case TypeReport.Tour:
model.EventEmployees = await GetEvent(dto, TypeEvent.Tour);
break;
case TypeReport.Cultural:
model.CulturalEmployees = await GetCultural(dto);
break;
case TypeReport.Gift:
model.GiftEmployees = await GetGift(dto);
break;
default:
throw new ArgumentOutOfRangeException();
}
return(model);
}
private async Task <IEnumerable <MaterialIncentivesEmployeeEntity> > GetMaterialAid(ReportPdfDTO dto)
{
var id = _hashIdUtilities.DecryptLong(dto.HashEmployeeId);
var result = await _context.MaterialAidEmployees
.Include(x => x.IdMaterialAidNavigation)
.Where(x => x.DateIssue.Between(dto.StartDate, dto.EndDate) && x.IdEmployee == id)
.OrderBy(x => x.DateIssue)
.ToListAsync();
return(_mapperService.Mapper.Map <IEnumerable <MaterialIncentivesEmployeeEntity> >(result));
}
