private async Task SendReportWithGroupingAsync(ReportsExportEmailView emailData, ReportTotalView groupedList)
{
var fileByte = await CreateFileOfBytesReportsGridAsync(emailData, groupedList);
#region Create and send message with file Attachment.
// Create builder for message body
var builder = new BodyBuilder
{
TextBody = emailData.Comment ?? string.Empty,
};
// Add file to message body
builder.Attachments.Add(FileName, fileByte);
var multipart = builder.ToMessageBody();
var emailSender = new EmailSender(_configuration);
emailSender.CreateSimpleMessage(emailData.ToEmail, multipart, emailData.Subject ?? FileName, emailData.CcEmails, emailData.BccEmails);
await emailSender.SendMessageAsync();
#endregion
}
public async Task <object> ExportEmailGroupedByType(ReportsExportEmailView reportsExportEmailView)
{
var groupByProjects = _reportService.GetReportsGrid(reportsExportEmailView);
await SendReportWithGroupingAsync(reportsExportEmailView, groupByProjects);
return(await Task.FromResult <object>(new object()));
}
public async Task <IActionResult> ReportsExportEmail([FromBody] ReportsExportEmailView reportsExportEmailView)
{
var result = await _service.ExportEmailGroupedByType(reportsExportEmailView);
if (result == null)
{
return(BadRequest());
}
return(Ok());
}
public async Task <IActionResult> ReportsExportEmail([FromBody] ReportsExportEmailView reportsGridData)
{
try
{
var userName = this.GetUserNameWithImpersonation();
switch (reportsGridData.CurrentQuery.GroupById)
{
case (int)ReportsGroupBy.Project:
{
await _service.ExportEmailGroupByProjects(userName, reportsGridData);
break;
}
case (int)ReportsGroupBy.User:
{
await _service.ExportEmailGroupByUsers(userName, reportsGridData);
break;
}
case (int)ReportsGroupBy.Date:
{
await _service.ExportEmailGroupByDates(userName, reportsGridData);
break;
}
case (int)ReportsGroupBy.Client:
{
await _service.ExportEmailGroupByClients(userName, reportsGridData);
break;
}
default:
{
await _service.ExportEmailGroupByNone(userName, reportsGridData);
break;
}
}
return(Ok());
}
catch (Exception e)
{
_logger.LogWarning($"ReportsExportEmail method with parameters ({reportsGridData});\n {e}");
var errors = ExceptionsChecker.CheckProjectsException(e);
return(BadRequest(errors));
}
}
public async Task ExportEmailGroupByClients(string userName, ReportsExportEmailView emailData)
{
var groupByClients = _reportService.ReportsGridGroupByClients(userName, emailData);
await SendReportWithGroupingAsync(emailData, groupByClients);
}
public async Task ExportEmailGroupByDates(ReportsExportEmailView emailData)
{
var groupByDates = _reportService.ReportsGridGroupByDates(emailData);
await SendReportWithGroupingAsync(emailData, groupByDates);
}
public async Task SendWeeklyTimeEntryUpdatesAsync(string baseUrl)
{
var todayDate = DateTime.Now;
if (IsDayOfWeekStart(todayDate))
{
var currentHour = todayDate.TimeOfDay.Hours;
if (currentHour == 1)
{
CommonHelpers.SetRangeOfLastWorkWeekByDate(out var lastWorkWeekFirstDay, out var lastWorkWeekLastDay, todayDate);
var diffDates = (lastWorkWeekLastDay - lastWorkWeekFirstDay).TotalDays;
var editionPeriodDays = GetRangeNotificationDaysForLastWeek(lastWorkWeekFirstDay, diffDates);
var memberStartDayOfWeekStartByTodayDate = GetMemberStartDayOfWeekStartByTodayDate(todayDate);
var members = Uow.MemberRepository.LinkedCacheGetList()
.Where(member => member.IsWeeklyTimeEntryUpdatesSend && member.WeekStart == memberStartDayOfWeekStartByTodayDate)
.Select(member => new
{
MemberId = member.Id,
MemberFullName = member.FullName,
MemberDateFormatId = member.DateFormatId,
MemberEmail = member.User.Email,
Project = member.MemberProjectRoles.Select(project => new
{
Id = project.Project.Id,
Name = project.Project.Name,
})
}).ToList();
foreach (var member in members)
{
var memberWithProjectsNotifications = new MemberWithProjecsNotifications
{
MemberId = member.MemberId,
MemberFullName = member.MemberFullName,
MemberDateFormatId = member.MemberDateFormatId,
MemberEmail = member.MemberEmail
};
var isNotFillTimeEntries = false;
var isAnyFillTimeEntries = false;
foreach (var project in member.Project)
{
var dateTimeEntryByNotificationRange = Uow.TimeEntryRepository.GetQueryWithIncludes()
.Where(tEntry => tEntry.ProjectId == project.Id && tEntry.MemberId == member.MemberId)
.Where(tEntry => tEntry.Date.Date >= lastWorkWeekFirstDay && tEntry.Date.Date <= lastWorkWeekLastDay)
.Select(tEntry => tEntry.Date.Date)
.ToList();
var datesWithoutTimeEntries = editionPeriodDays.Except(dateTimeEntryByNotificationRange).ToArray();
var hasNotTimeEntries = dateTimeEntryByNotificationRange.Count == 0;
var hasAnyTimeEntries = dateTimeEntryByNotificationRange.Any() && datesWithoutTimeEntries.Any();
//var hasAllTimeEntries = datesWithoutTimeEntries.Length == 0;
if (hasNotTimeEntries)
{
if (!isAnyFillTimeEntries)
{
isNotFillTimeEntries = true;
}
}
if (hasAnyTimeEntries)
{
isNotFillTimeEntries = false;
isAnyFillTimeEntries = true;
}
}
if (isNotFillTimeEntries || isAnyFillTimeEntries)
{
var subjectNotFilledTimeEnttries = CreateEmailSubjectWeeklyTimeEntryUpdates(memberWithProjectsNotifications.MemberEmail);
var emailText = CreateEmailTextWeeklyNotifications(baseUrl, memberWithProjectsNotifications, isNotFillTimeEntries, isAnyFillTimeEntries);
Uow.MemberImpersonated = Uow.MemberRepository.GetQueryByMemberId(memberWithProjectsNotifications.MemberId);
var reportsExportEmailView = new ReportsExportEmailView
{
Comment = emailText,
DateFormatId = memberWithProjectsNotifications.MemberDateFormatId,
FileTypeId = (int)Constants.FileType.Excel,
Subject = subjectNotFilledTimeEnttries,
ToEmail = memberWithProjectsNotifications.MemberEmail,
CurrentQuery = new ReportsSettingsView
{
DateFrom = lastWorkWeekFirstDay,
DateTo = lastWorkWeekLastDay,
GroupById = (int)Constants.ReportsGroupByIds.Project,
ShowColumnIds = new[] { 1, 2, 3, 4 }
}
};
await _reportExportService.ExportEmailGroupedByType(reportsExportEmailView);
}
}
}
}
}
