private async Task SendFinalApprovalMail(cor_workflowtask task)
{
var initiator = await _userManager.FindByIdAsync(task.CreatedBy);
if (initiator != null)
{
var sm = new SendEmailCommand();
sm.Subject = $"{task.Comment} <b>Final approval process successful <b>";
sm.Content = $"Hello {initiator.UserName} <br/>" +
$"This is to inform you of {task.Comment}, initiated by you on {task.CreatedOn} has been finally approved on {DateTime.Today}";
sm.ToAddresses.Add(new EmailAddressCommand {
Address = initiator.Email, Name = initiator.UserName
});
var mailSent = await _email.BuildAndSaveEmail(sm);
EmailMessage em = new EmailMessage
{
Subject = sm.Subject,
Content = sm.Content,
FromAddresses = mailSent.FromAddresses,
ToAddresses = _mapper.Map <List <EmailAddress> >(sm.ToAddresses),
};
em.Module = (int)Modules.CENTRAL;
await _email.Send(em);
}
}
public async Task <bool> CreateUpdateWorkflowTaskAsync(cor_workflowtask model)
{
if (model.WorkflowTaskId > 0)
{
var item = await _dataContext.cor_workflowtask.FindAsync(model.WorkflowTaskId);
_dataContext.Entry(item).CurrentValues.SetValues(model);
}
else
{
await _dataContext.cor_workflowtask.AddAsync(model);
}
return(await _dataContext.SaveChangesAsync() > 0);
}
public async Task <StaffApprovalRegRespObj> Handle(StaffApprovalCommand request, CancellationToken cancellationToken)
{
var _ApiResponse = new StaffApprovalRegRespObj {
Status = new APIResponseStatus {
IsSuccessful = true, Message = new APIResponseMessage()
}
};
try
{
if (request.ApprovalStatus == (int)ApprovalStatus.Revert && request.ReferredStaffId < 1)
{
_ApiResponse.Status.IsSuccessful = false;
_ApiResponse.Status.Message.FriendlyMessage = "Please select staff to revert to";
return(_ApiResponse);
}
var currentUserId = _accessor.HttpContext.User?.FindFirst(x => x.Type == "userId").Value;
var user = await _userManager.FindByIdAsync(currentUserId);
var taskList = await _repo.GetAllWorkflowTaskAsync();
_AllTaskForThisTarget = taskList.Where(d => d.TargetId == request.TargetId && d.WorkflowToken.Trim().ToLower() == request.WorkflowToken.Trim().ToLower()).ToList();
_CurrentStaffTask = taskList.LastOrDefault(d => d.TargetId == request.TargetId && d.StaffEmail.Trim().ToLower() == user.Email.Trim().ToLower());
if (_CurrentStaffTask == null)
{
_ApiResponse.Status.IsSuccessful = false;
_ApiResponse.Status.Message.FriendlyMessage = "Task not available";
return(_ApiResponse);
}
using (var _trans = await _data.Database.BeginTransactionAsync())
{
try
{
if (request.ApprovalStatus == (int)ApprovalStatus.Approved)
{
var allTaskForThisTarget = await _repo.GetCurrentWorkTaskAsync(_CurrentStaffTask.OperationId,
request.TargetId, _CurrentStaffTask.WorkflowId, request.WorkflowToken);
var pendinTask = allTaskForThisTarget.OrderBy(g => g.Position).FirstOrDefault(x => x.WorkflowTaskStatus == (int)WorkflowTaskStatus.Created);
if (await UpdateApprovedTasksWithMuthipleStaffAsync(request))
{
if (await SendToNextStaffAsync(request))
{
await _trans.CommitAsync();
_ApiResponse.ResponseId = (int)ApprovalStatus.Processing;
_ApiResponse.Status.Message.FriendlyMessage = "Successfully approved";
if (await IsFinalApprovalAsync(request))
{
await FinalizeAsync(request);
_ApiResponse.ResponseId = (int)ApprovalStatus.Approved;
_ApiResponse.Status.Message.FriendlyMessage = "Final Aproval Successful";
}
return(_ApiResponse);
}
}
else
{
_CurrentStaffTask.WorkflowTaskStatus = (int)WorkflowTaskStatus.Done;
_CurrentStaffTask.TargetId = request.TargetId;
await _repo.CreateUpdateWorkflowTaskAsync(_CurrentStaffTask);
if (await SendToNextStaffAsync(request))
{
await _trans.CommitAsync();
_ApiResponse.ResponseId = (int)ApprovalStatus.Processing;
_ApiResponse.Status.Message.FriendlyMessage = "Successfully approved";
if (await IsFinalApprovalAsync(request))
{
await FinalizeAsync(request);
_ApiResponse.ResponseId = (int)ApprovalStatus.Approved;
_ApiResponse.Status.Message.FriendlyMessage = "Final Aproval Successful";
}
return(_ApiResponse);
}
if (await IsFinalApprovalAsync(request))
{
await FinalizeAsync(request);
await _trans.CommitAsync();
_ApiResponse.ResponseId = (int)ApprovalStatus.Approved;
_ApiResponse.Status.Message.FriendlyMessage = "Final Aproval Successful";
return(_ApiResponse);
}
}
}
if (request.ApprovalStatus == (int)ApprovalStatus.Disapproved)
{
if (await DisapproveAllTaskForthisOperationAsync())
{
await _trans.CommitAsync();
_ApiResponse.ResponseId = (int)ApprovalStatus.Disapproved;
_ApiResponse.Status.Message.FriendlyMessage = "Successfully Disapproved";
}
return(_ApiResponse);
}
if (request.ApprovalStatus == (int)ApprovalStatus.Revert)
{
if (!await StaffToBeRevertedToExistAsync(request))
{
await _trans.RollbackAsync();
_ApiResponse.Status.IsSuccessful = false;
_ApiResponse.Status.Message.FriendlyMessage = "Staff not found in approval line";
return(_ApiResponse);
}
await UpdateSingleOrMultipleRevertingStaffAsync(request);
if (await RevertToSingleOrMultipleStaffAsync(request))
{
await _trans.CommitAsync();
_ApiResponse.ResponseId = (int)ApprovalStatus.Revert;
_ApiResponse.Status.Message.FriendlyMessage = "Successfully Referred";
return(_ApiResponse);
}
}
}
catch (SqlException ex) { await _trans.RollbackAsync(); }
finally { await _trans.DisposeAsync(); }
}
_ApiResponse.Status.IsSuccessful = false;
_ApiResponse.Status.Message.FriendlyMessage = "No Approval Status selected";
return(_ApiResponse);
}
catch (Exception ex)
{
#region Log error to file
var errorCode = ErrorID.Generate(4);
_logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
_ApiResponse.Status.IsSuccessful = false;
_ApiResponse.Status.Message.FriendlyMessage = "Error occured!! Unable to process request";
_ApiResponse.Status.Message.TechnicalMessage = $"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}";
_ApiResponse.Status.Message.MessageId = errorCode;
return(_ApiResponse);
#endregion
}
}
public async Task <GoForApprovalRespObj> Handle(GoForApprovalCommand request, CancellationToken cancellationToken)
{
var operationList = await _repo.GetAllOperationAsync();
var workflowflowAccessList = await _repo.GetAllWorkflowAccessAsync();
var staffList = await _adminRepo.GetAllStaffAsync();
var workflowLevelList = await _repo.GetAllWorkflowLevelAsync();
var workflowLevelStaffList = await _repo.GetAllWorkflowLevelStaffAsync();
var workflowDetailList = await _repo.GetAllWorkflowdetailsAsync();
var currentUserId = _httpContextAccessor.HttpContext.User?.FindFirst(x => x.Type == "userId").Value;
var user = await _userManager.FindByIdAsync(currentUserId);
var currentUserStaffData = staffList.FirstOrDefault(d => d.StaffId == user.StaffId);
var validationResponse = ValidateRequest(request);
if (!validationResponse.Status.IsSuccessful)
{
return(validationResponse);
}
try
{
if (!(bool)operationList.FirstOrDefault(x => x.OperationId == request.OperationId).EnableWorkflow)
{
return(new GoForApprovalRespObj
{
EnableWorkflow = false,
HasWorkflowAccess = true,
ApprovalProcessStarted = false,
Status = new APIResponseStatus
{
IsSuccessful = true,
Message = new APIResponseMessage
{
FriendlyMessage = "Workflow not enabled for this company! please go ahead with process"
}
}
});
}
var thisStaffWorkflowAccess = workflowflowAccessList.FirstOrDefault(x => x.OfficeAccessId == currentUserStaffData.StaffOfficeId && x.OperationId == request.OperationId);
if (thisStaffWorkflowAccess == null)
{
return(new GoForApprovalRespObj
{
EnableWorkflow = true,
HasWorkflowAccess = false,
Status = new APIResponseStatus {
IsSuccessful = true, Message = new APIResponseMessage {
FriendlyMessage = "There is no approval workflow setup for your access level"
}
}
});
}
var thisOperationworkflow = _dataContext.cor_workflow.FirstOrDefault(c => c.OperationId == request.OperationId);
var thisOperationWorkflowDetails = workflowDetailList.Where(x => x.WorkflowId == thisOperationworkflow.WorkflowId && x.OperationId == request.OperationId).OrderBy(c => c.Position).ToList();
var wkfLevelaccessList = new List <int>();
foreach (var approver in thisOperationWorkflowDetails)
{
wkfLevelaccessList.Add(Convert.ToInt32(approver.WorkflowLevelId));
}
var StaffBindedObj = (from wkflstaff in workflowLevelStaffList
join wkfl in workflowLevelList on wkflstaff.WorkflowLevelId equals wkfl.WorkflowLevelId
join thisOpWkDetail in thisOperationWorkflowDetails on wkflstaff.WorkflowLevelId equals thisOpWkDetail.WorkflowLevelId
where wkfLevelaccessList.Contains(wkflstaff.WorkflowLevelId)
select new InMemoryStaffObject
{
StaffId = wkflstaff.StaffId,
WorkflowLevelId = wkfl.WorkflowLevelId
}).ToList();
List <InMemoryStaffObject> WorkflowLevelStaffObject = new List <InMemoryStaffObject>();
if (StaffBindedObj.Count() > 0)
{
foreach (var staff in StaffBindedObj.OrderBy(s => s.Position))
{
var newStaffObj = new InMemoryStaffObject
{
Email = staffList.FirstOrDefault(s => s.StaffId == staff.StaffId)?.Email,
StaffOfficeId = staffList.FirstOrDefault(s => s.StaffId == staff.StaffId)?.AccessLevel ?? 0,
StaffId = staff.StaffId,
Position = thisOperationWorkflowDetails.FirstOrDefault(d => d.WorkflowLevelId == staff.WorkflowLevelId).Position,
Name = $"{staffList.FirstOrDefault(s => s.StaffId == staff.StaffId)?.FirstName} {staffList.FirstOrDefault(s => s.StaffId == staff.StaffId)?.LastName}",
WorkflowLevelId = staff.WorkflowLevelId
};
WorkflowLevelStaffObject.Add(newStaffObj);
}
}
if (StaffBindedObj.Count() < 1)
{
StaffBindedObj = new List <InMemoryStaffObject>();
WorkflowLevelStaffObject = new List <InMemoryStaffObject>();
var thisOperationGrouped = workflowLevelList
.Where(s => thisOperationWorkflowDetails.GroupBy(w => w.WorkflowGroupId).First()
.Select(g => g.WorkflowGroupId).Contains(s.WorkflowGroupId))
.Select(c => new Groups()
{
GroupID = c.WorkflowGroupId
}).ToList();
if (thisOperationGrouped.Count() < 1)
{
return(new GoForApprovalRespObj
{
EnableWorkflow = true,
HasWorkflowAccess = true,
ApprovalProcessStarted = false,
Status = new APIResponseStatus {
IsSuccessful = true, Message = new APIResponseMessage {
FriendlyMessage = "No Workflow Group Found for this Operation"
}
}
});
}
var thisOperationGroupedLevels = thisOperationWorkflowDetails
.Where(s => thisOperationGrouped
.Select(r => r.GroupID).Contains(s.WorkflowGroupId))
.Select(e => new Levels()
{
GroupID = e.WorkflowGroupId, WorkflowLevelId = e.WorkflowLevelId
}).ToList();
if (thisOperationGroupedLevels.Count() < 1)
{
return(new GoForApprovalRespObj
{
EnableWorkflow = true,
HasWorkflowAccess = true,
ApprovalProcessStarted = false,
Status = new APIResponseStatus {
IsSuccessful = true, Message = new APIResponseMessage {
FriendlyMessage = "No Workflow Level Found for this Operation"
}
}
});
}
var titlesOfLevelsGrouped = (from a in thisOperationWorkflowDetails
join b in thisOperationGroupedLevels
on new
{
X1 = a.WorkflowLevelId,
X2 = a.WorkflowGroupId
}
equals new
{
X1 = b.WorkflowLevelId,
X2 = b.GroupID
}
join c in workflowLevelList on b.WorkflowLevelId equals c.WorkflowLevelId
join d in staffList on int.Parse(c.RoleId) equals d.JobTitle
orderby c.Position
select new InMemoryStaffObject
{
StaffId = d.StaffId,
WorkflowLevelId = b.WorkflowLevelId,
Position = a.Position,
Email = d.Email,
Name = $"{staffList.FirstOrDefault(s => s.StaffId == d.StaffId)?.FirstName} {staffList.FirstOrDefault(s => s.StaffId == d.StaffId)?.LastName}",
StaffOfficeId = d?.AccessLevel ?? 0,
GroupId = a.WorkflowGroupId
}).ToList();
WorkflowLevelStaffObject = titlesOfLevelsGrouped;
}
var TaskToken = CustomToken.Generate();
using (var _trans = await _dataContext.Database.BeginTransactionAsync())
{
try
{
foreach (var target in request.TargetId)
{
cor_workflowtask appproverTask = new cor_workflowtask();
foreach (var staff in WorkflowLevelStaffObject)
{
appproverTask = new cor_workflowtask();
appproverTask.Active = true;
appproverTask.Comment = request.Comment;
appproverTask.CompanyId = request.CompanyId;
appproverTask.CreatedBy = user.UserName;
appproverTask.CreatedOn = DateTime.Now;
appproverTask.DefferedExecution = request.DeferredExecution;
appproverTask.Deleted = false;
appproverTask.OperationId = request.OperationId;
appproverTask.StaffAccessId = staff.StaffOfficeId;
appproverTask.StaffEmail = staff.Email;
appproverTask.StaffId = staff.StaffId;
appproverTask.StaffRoles = string.Join(',', await _adminRepo.GetStaffRolesAsync(staff.StaffId));
appproverTask.TargetId = target;
appproverTask.WorkflowId = thisOperationworkflow.WorkflowId;
appproverTask.WorkflowTaskId = request.WorkflowTaskId;
appproverTask.ApprovalStatus = (int)ApprovalStatus.Pending;
appproverTask.Date = DateTime.Now;
appproverTask.Position = staff.Position;
appproverTask.WorkflowToken = TaskToken;
if (request.WorkflowTaskId < 1)
{
appproverTask.WorkflowTaskStatus = (int)WorkflowTaskStatus.Created;
appproverTask.ApprovalStatus = (int)ApprovalStatus.Processing;
if (appproverTask.Position == 1)
{
appproverTask.IsMailSent = true;
await SendMail(appproverTask.StaffEmail, staff.Name, appproverTask.Comment);
//Send Mail...................
}
if (!await _repo.CreateUpdateWorkflowTaskAsync(appproverTask))
{
await _trans.RollbackAsync();
return(new GoForApprovalRespObj
{
EnableWorkflow = true,
HasWorkflowAccess = true,
ApprovalProcessStarted = false,
Status = new APIResponseStatus {
IsSuccessful = true, Message = new APIResponseMessage {
FriendlyMessage = "Approval Process failled to start"
}
}
});
}
}
}
}
await _trans.CommitAsync();
return(new GoForApprovalRespObj
{
EnableWorkflow = true,
HasWorkflowAccess = true,
ApprovalProcessStarted = true,
Status = new APIResponseStatus {
CustomToken = TaskToken, IsSuccessful = true, Message = new APIResponseMessage {
FriendlyMessage = "Approval Process started"
}
}
});
}
catch (Exception ex)
{
var errorCode = ErrorID.Generate(7);
await _trans.RollbackAsync();
_logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
return(new GoForApprovalRespObj
{
EnableWorkflow = false,
HasWorkflowAccess = false,
ApprovalProcessStarted = false,
Status = new APIResponseStatus
{
IsSuccessful = false,
Message = new APIResponseMessage
{
FriendlyMessage = "Error Occured While processing request!! Please check your technical message",
TechnicalMessage = ex?.Message ?? ex?.InnerException.Message + ex?.StackTrace,
}
}
});
}
finally { await _trans.DisposeAsync(); }
}
}
catch (Exception ex)
{
#region Log error to file
var errorCode = ErrorID.Generate(4);
_logger.Error($"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}");
return(new GoForApprovalRespObj
{
Status = new APIResponseStatus
{
IsSuccessful = false,
Message = new APIResponseMessage
{
FriendlyMessage = "Error occured!! Unable to process item",
MessageId = errorCode,
TechnicalMessage = $"ErrorID : {errorCode} Ex : {ex?.Message ?? ex?.InnerException?.Message} ErrorStack : {ex?.StackTrace}"
}
}
});
#endregion
}
}