Esempio n. 1
0
        private async Task SendReminders()
        {
            var thisWeek = WeekDTO.CreateWithWeekContaining(DateTime.Now);

            if (thisWeek.IsPPE.Value)
            {
                var beginDate = thisWeek.Previous().WeekStart;
                var endDate   = thisWeek.WeekEnd;
                var entries   = (await _timeApprovalService.GetByStatus(beginDate, endDate, TimeApprovalStatus.Unkown)).ToList();
                var template  = await System.IO.File.ReadAllTextAsync(@"wwwroot\email-submit-time-reminder.html");

                foreach (var entry in entries.GroupBy(x => x.EmployeeId))
                {
                    try
                    {
                        var emp = await _employeeRepository.GetSingleEmployeeAsync(entry.Key);

                        _logger.Information($"sending reminder to {emp.First} {emp.Last} [{emp.UserName}]");

                        _smtpProxy.SendMail(emp.UserName, template, $"Reminder to submit time for {beginDate.ToShortDateString()}-{endDate.ToShortDateString()}");
                    }
                    catch (Exception e)
                    {
                        _logger.Error(e, "error trying to send reminder");
                    }
                }
            }
        }
Esempio n. 2
0
        public async Task <Result> ApplyApproval(TimeApprovalRequest request)
        {
            var current = await timeApprovalService.GetAsync(request.WeekId, request.EmployeeId);

            var isValidSubmit = request.NewApprovalState == TimeEntries.TimeApprovalStatus.Submitted &&
                                !(current.TimeApprovalStatus == TimeApprovalStatus.Submitted || current.TimeApprovalStatus == TimeApprovalStatus.Approved);
            var isValidReject = request.NewApprovalState == TimeEntries.TimeApprovalStatus.Rejected &&
                                (current.TimeApprovalStatus == TimeApprovalStatus.Submitted || current.TimeApprovalStatus == TimeApprovalStatus.Approved) &&
                                request.ApprovingUserIsAdmin;
            var isValidApprove = request.NewApprovalState == TimeApprovalStatus.Approved &&
                                 request.ApprovingUserIsAdmin;

            if (isValidSubmit)
            {
                var time = await timeService.GetAsync(request.WeekId, request.EmployeeId);

                var totalOt  = time.Sum(x => x.OvertimeHours);
                var totalReg = time.Sum(x => x.Hours);
                current.TotalOverTimeHours = totalOt;
                current.TotalRegularHours  = totalReg;

                if (totalOt > 0 || totalReg > 40)
                {
                    current.TimeApprovalStatus = TimeApprovalStatus.Submitted;
                }
                else
                {
                    current.TimeApprovalStatus = TimeApprovalStatus.Approved;
                }
            }
            if (isValidReject || isValidApprove)
            {
                current.TimeApprovalStatus = request.NewApprovalState;
            }
            if (isValidApprove)
            {
                var approvedBy = request.ApprovingUserId == request.EmployeeId ? "[AUTO APPROVED BY SYSTEM]" : "approved by manager";
                var approver   = await employeeService.GetSingleEmployeeAsync(request.ApprovingUserId);

                current.ApproverName = approver.UserName;
                current.ApprovalDate = DateTime.Now;
                var week = WeekDTO.CreateForWeekId(request.WeekId);
                var emp  = await employeeService.GetSingleEmployeeAsync(request.EmployeeId);

                string finalEmailText = await CreateEmailBody(week, emp,
                                                              greetingName : emp.First,
                                                              action : $"Time sheet approved (for the week {week.WeekStart.ToShortDateString()}-{week.WeekEnd.ToShortDateString()})",
                                                              actionBy : approvedBy, followup : "No further action is required.");

                var recipient = emp.UserName;
                smtpProxy.SendMail(recipient, finalEmailText, $"Time approved for week {week.WeekStart.ToShortDateString()}-{week.WeekEnd.ToShortDateString()}");
            }

            await timeApprovalService.Save(current);


            if (isValidSubmit && current.TimeApprovalStatus == TimeApprovalStatus.Submitted)
            {
                var time = await timeService.GetAsync(request.WeekId, request.EmployeeId);

                var JobsThatCauseApprovalRequired = time.Where(x => x.OvertimeHours > 0).GroupBy(x => x.JobId);
                var jobDetails = await Task.WhenAll(JobsThatCauseApprovalRequired.Select(async x => (await jobService.GetForJobId(x.Key)).CoreInfo));

                int[] projectManagersToNotifiy = jobDetails.Select(x => x.ProjectManagerEmployeeId).ToArray();
                var   week = WeekDTO.CreateForWeekId(request.WeekId);
                foreach (var pm in projectManagersToNotifiy)
                {
                    var emp = await employeeService.GetSingleEmployeeAsync(request.EmployeeId);

                    var approver = await employeeService.GetSingleEmployeeAsync(pm);

                    var recipient = approver.UserName;

                    string finalEmailText = await CreateEmailBody(week, emp,
                                                                  greetingName : approver.First,
                                                                  action : $"submitted for approval (for the week {week.WeekStart.ToShortDateString()}-{week.WeekEnd.ToShortDateString()})",
                                                                  actionBy : $"{emp.First} {emp.Last}", followup : $"You will need to review the timesheet as you are marked as a project manager a job in this week.");

                    smtpProxy.SendMail(recipient, finalEmailText, $"Time submitted for week {week.WeekStart.ToShortDateString()}-{week.WeekEnd.ToShortDateString()}");
                }
            }

            if (isValidReject)
            {
                var week = WeekDTO.CreateForWeekId(request.WeekId);
                var emp  = await employeeService.GetSingleEmployeeAsync(request.EmployeeId);

                var approver = await employeeService.GetSingleEmployeeAsync(request.ApprovingUserId);

                var recipient = emp.UserName;

                string finalEmailText = await CreateEmailBody(week, emp,
                                                              greetingName : emp.First,
                                                              action : $"{request.NewApprovalState}",
                                                              actionBy : $"{approver.First} {approver.Last}",
                                                              followup : $"Please review and resubmit for the week {week.WeekStart.ToShortDateString()}-{week.WeekEnd.ToShortDateString()}.");

                smtpProxy.SendMail(recipient, finalEmailText, $"Time {request.NewApprovalState} for week {week.WeekStart.ToShortDateString()}-{week.WeekEnd.ToShortDateString()}");
            }
            return(new Result(true));
        }