Example #1
0
        private string CreateEmailTextForEmailByProjectSettings(string baseUrl, MemberWithProjecsNotifications memberWithProjecsNotifications)
        {
            var sbEmailText = new StringBuilder($"<p>Hello, {memberWithProjecsNotifications.MemberFullName}!<br><p>This is a friendly reminder, that you haven’t entered your Time Entries on ");

            if (memberWithProjecsNotifications.ProjectsWithDatesEditing.Count > 1)
            {
                sbEmailText.Append("the following projects:<br>");
            }

            var dateFormatShort = new GetDateFormat().GetDateFormaDotNetShortById(memberWithProjecsNotifications.MemberDateFormatId);

            var indexCurrentProject = 0;

            foreach (var project in memberWithProjecsNotifications.ProjectsWithDatesEditing)
            {
                var dayOrDays = project.EditionDays.EditionDays.Length > 1 ? "days" : "day";

                if (memberWithProjecsNotifications.ProjectsWithDatesEditing.Count > 1)
                {
                    sbEmailText.Append($"{++indexCurrentProject}. ");
                }

                var editionDaysFormat = string.Join(", </b><b>",
                                                    project.EditionDays.EditionDays.Select(x => x.ToString(dateFormatShort, CultureInfo.InvariantCulture)));
                var sbEditionDaysFormat = new StringBuilder($"<b>{editionDaysFormat}</b>");

                sbEmailText.Append($"<b>{project.ProjectWithDatesEditing.Name}</b> project for <b>{project.EditionDays.EditionDays.Length}</b> work{dayOrDays}: {sbEditionDaysFormat}.<br>");
            }

            sbEmailText.Append($"<p><a href=\"{baseUrl}/calendar/\">Would you like to enter your time now?</a><br><p>Best wishes, <a href=\"mailto:[email protected]\">CoralTime Team!</a>");

            return(sbEmailText.ToString());
        }
        private string CreateEmailTextWeeklyNotifications(string baseUrl, MemberWithProjecsNotifications memberWithProjectsNotifications, bool isNotFillTimeEntries, bool isAnyFillTimeEntries)
        {
            var sbEmailText = new StringBuilder($"Hello, {memberWithProjectsNotifications.MemberFullName}! ");

            if (isNotFillTimeEntries)
            {
                sbEmailText.Append("It seems you haven’t filled any Time Entries for the last week. ");
                sbEmailText.Append("Would you like to track your time now?");
            }

            if (isAnyFillTimeEntries)
            {
                sbEmailText.Append("You could find your hours tracked last week attached to this letter. ");
                sbEmailText.Append("Would you like to change your time entries now?");
            }

            //sbEmailText.Append($"<a href=\"{baseUrl}/calendar/\">");
            sbEmailText.Append($"{baseUrl}/calendar/\"");

            return(sbEmailText.ToString());
        }
        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);
                        }
                    }
                }
            }
        }
Example #4
0
        private async Task GetMembersWithNotificationsProjectsAsync(DateTime todayDate, string baseUrl)
        {
            var currentHour = todayDate.TimeOfDay.Hours;

            var members = Uow.MemberRepository.LinkedCacheGetList()
                          .Where(member => member.SendEmailTime == currentHour && member.MemberProjectRoles.Any(mpr => mpr.Project.IsNotificationEnabled && mpr.Project.IsActive && mpr.Project.IsPrivate && mpr.Project.NotificationDay > 0))
                          .Select(member => new
            {
                MemberId           = member.Id,
                MemberFullName     = member.FullName,
                MemberDateFormatId = member.DateFormatId,
                MemberEmail        = member.User.Email,

                Projects = member.MemberProjectRoles.Where(mpr => mpr.Project.IsNotificationEnabled && mpr.Project.IsActive && mpr.Project.IsPrivate && mpr.Project.NotificationDay > 0).Select(project => new
                {
                    Id              = project.Project.Id,
                    Name            = project.Project.Name,
                    NotificationDay = project.Project.NotificationDay
                })
            }).ToList();

            foreach (var member in members)
            {
                var memberWithProjectsNotifications = new MemberWithProjecsNotifications
                {
                    MemberId           = member.MemberId,
                    MemberFullName     = member.MemberFullName,
                    MemberDateFormatId = member.MemberDateFormatId,
                    MemberEmail        = member.MemberEmail
                };

                foreach (var project in member.Projects)
                {
                    var editionPeriodDays = GetRangeNotificationDays(todayDate, project.NotificationDay, out var notificationPeriodFirstDay, out var notificationPeriodLastDay);

                    var dateTimeEntryByNotificationRange = Uow.TimeEntryRepository.GetQueryWithIncludes()
                                                           .Where(tEntry => tEntry.ProjectId == project.Id && tEntry.MemberId == member.MemberId)
                                                           .Where(tEntry => tEntry.Date.Date >= notificationPeriodFirstDay && tEntry.Date.Date <= notificationPeriodLastDay)
                                                           .Select(tEntry => tEntry.Date)
                                                           .ToList();

                    var datesThatNotContainsTimeEntries = editionPeriodDays.Except(dateTimeEntryByNotificationRange).Select(g => g.Date.Date).ToArray();
                    if (datesThatNotContainsTimeEntries.Length > 0)
                    {
                        var projectWithDatesEditing = new ProjectsWithDatesEditing
                        {
                            ProjectWithDatesEditing = new ProjectWithNotifications
                            {
                                Id   = project.Id,
                                Name = project.Name,
                            },

                            EditionDays = new ProjectEditionDays
                            {
                                EditionDays = datesThatNotContainsTimeEntries,
                                NotificationPeriodFirstDay = notificationPeriodFirstDay,
                                NotificationPeriodLastDay  = notificationPeriodLastDay
                            }
                        };

                        memberWithProjectsNotifications.ProjectsWithDatesEditing.Add(projectWithDatesEditing);
                    }

                    var subjectByProjectSettings   = CreateEmailSubjectByProjectSettings(memberWithProjectsNotifications.MemberEmail);
                    var emailTextByProjectSettings = CreateEmailTextForEmailByProjectSettings(baseUrl, memberWithProjectsNotifications);

                    await CreateAndSendEmailNotificationForUserAsync(emailTextByProjectSettings, memberWithProjectsNotifications.MemberEmail, subjectByProjectSettings);
                }
            }
        }