/// <summary>
/// Method to get last leave status and details on slack
/// </summary>
/// <param name="slackText">list of string contain leave slash command parameter</param>
/// <param name="leave">leave slash command</param>
/// <param name="accessToken">User's access token</param>
/// <returns>Reply text to be send</returns>
private async Task <string> SlackLeaveStatusAsync(List <string> slackText, SlashCommand leave, string accessToken)
{
// if slackText count is more then 1 then its means that user want to get leave list of someone else
if (slackText.Count > 1)
{
// other user slack user name
SlackUserDetailAc slackUser = await _slackUserRepository.GetBySlackNameAsync(slackText[1]);
if (slackUser != null)
{
var user = await _userManagerRepository.FirstOrDefaultAsync(x => x.SlackUserId == slackUser.UserId);
_logger.Debug("SlackLeaveStatusAsync user name other : " + user.UserName);
// last leave details of other user
replyText = await LeaveStatusBySlackUserIdAsync(user.Id, accessToken);
}
else
{
replyText = string.Format(_stringConstant.UserDetailsNotFound, slackText[1]);
}
}
else
{
var user = await _userManagerRepository.FirstOrDefaultAsync(x => x.SlackUserId == leave.UserId);
_logger.Debug("SlackLeaveStatusAsync user name own : " + user.UserName);
// last leave details of own
replyText = await LeaveStatusBySlackUserIdAsync(user.Id, accessToken);
}
return(replyText);
}
/// <summary>
/// Method to send slack message to user whom leave has been applied by admin
/// </summary>
/// <param name="leaveRequest">LeaveRequest object</param>
/// <param name="managementEmail">Management email address</param>
/// <param name="replyText">Reply text to be send to user</param>
/// <param name="user">User details</param>
public async Task SendSickLeaveMessageToUserIncomingWebhookAsync(LeaveRequest leaveRequest, string managementEmail, string replyText, User user)
{
_logger.Debug("SendSickLeaveMessageToUserIncomingWebhookAsync method");
var attachment = _attachmentRepository.SlackResponseAttachmentWithoutButton(Convert.ToString(leaveRequest.Id), replyText);
SlackUserDetailAc slackUser = await _slackUserRepository.GetByIdAsync(user.SlackUserId);
if (slackUser != null)
{
_logger.Debug("SendSickLeaveMessageToUserIncomingWebhookAsync user slack name : " + slackUser.Name);
var incomingWebHook = await _incomingWebHook.FirstOrDefaultAsync(x => x.UserId == slackUser.UserId);
var slashIncomingWebhookText = new SlashIncomingWebhook()
{
Channel = _stringConstant.AtTheRate + slackUser.Name, Username = _stringConstant.LeaveBot, Attachments = attachment
};
var slashIncomingWebhookJsonText = JsonConvert.SerializeObject(slashIncomingWebhookText);
if (incomingWebHook != null)
{
await _httpClientService.PostAsync(incomingWebHook.IncomingWebHookUrl, slashIncomingWebhookJsonText, _stringConstant.JsonContentString, null, null);
}
}
EmailApplication email = new EmailApplication();
email.To = new List <string>();
// creating email templates corresponding to leave applied
email.Body = _emailTemplateRepository.EmailServiceTemplateSickLeave(leaveRequest);
email.From = managementEmail;
email.Subject = _stringConstant.EmailSubject;
email.To.Add(user.Email);
_emailService.Send(email);
_logger.Debug("SendSickLeaveMessageToUserIncomingWebhookAsync Email sended successfully");
}
/// <summary>
/// Method to get slack user information by their slack user id
/// </summary>
/// <param name="slackId">slack user id</param>
/// <returns>object of SlackUserDetailAc</returns>
public async Task <SlackUserDetailAc> GetByIdAsync(string slackId)
{
SlackUserDetails slackUserDetail = await _slackUserDetailsRepository.FirstOrDefaultAsync(x => x.UserId == slackId);
SlackUserDetailAc slackUserDetailAc = _mapper.Map <SlackUserDetailAc>(slackUserDetail);
return(slackUserDetailAc);
}
/// <summary>
/// Method to get slack user information by their slack user name. - JJ
/// </summary>
/// <param name="userSlackName">slack user name</param>
/// <returns>object of SlackUserDetailAc</returns>
public async Task <SlackUserDetailAc> GetBySlackNameAsync(string userSlackName)
{
SlackUserDetails slackUserDetail = await _slackUserDetailsRepository.FirstOrDefaultAsync(x => x.Name == userSlackName);
SlackUserDetailAc slackUserDetailAc = _mapper.Map <SlackUserDetailAc>(slackUserDetail);
return(slackUserDetailAc);
}
public async Task GetByIdAsync()
{
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
SlackUserDetailAc slackUser = await _slackUserRepository.GetByIdAsync(_stringConstant.StringIdForTest);
Assert.Equal(slackUser.Name, _stringConstant.FirstNameForTest);
}
public async Task AddSlackUserAsync()
{
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
SlackUserDetailAc slackUserDetail = await _slackUserRepository.GetBySlackNameAsync(slackUserDetails.Name);
Assert.Equal(slackUserDetail.UserId, slackUserDetails.UserId);
}
public async Task GetBySlackName()
{
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
SlackUserDetailAc slackUser = _slackUserRepository.GetBySlackNameAsync(_stringConstant.FirstNameForTest).Result;
Assert.Equal(slackUser.UserId, _stringConstant.StringIdForTest);
}
public async Task SlackUserUpdate()
{
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
slackUserDetails.Name = _stringConstant.FalseStringNameForTest;
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
SlackUserDetailAc slackUser = _slackUserRepository.GetByIdAsync(_stringConstant.StringIdForTest).Result;
Assert.Equal(slackUser.Name, _stringConstant.FalseStringNameForTest);
}
public async Task <IHttpActionResult> RefreshTokenAsync(string refreshToken, string slackUserName)
{
var oAuth = _oAuthLoginRepository.ExternalLoginInformation(refreshToken);
SlackUserDetailAc user = await _slackUserRepository.GetBySlackNameAsync(slackUserName);
if (user != null)
{
oAuth.UserId = user.UserId;
}
return(Ok(oAuth));
}
public async Task GetByIdFalse()
{
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
slackUserDetails.UserId = _stringConstant.SlackChannelIdForTest;
slackUserDetails.Name = _stringConstant.FalseStringNameForTest;
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
SlackUserDetailAc slackUser = _slackUserRepository.GetByIdAsync(_stringConstant.SlackChannelIdForTest).Result;
Assert.NotEqual(slackUser.Name, _stringConstant.FirstNameForTest);
}
/// <summary>
/// Method to get leave Updated from slack button response
/// </summary>
/// <param name="leaveResponse">leave update response from slack</param>
public async Task UpdateLeaveAsync(SlashChatUpdateResponse leaveResponse)
{
try
{
_logger.Debug("UpdateLeaveAsync Leave update method");
// method to get leave by its id
LeaveRequest leave = await _leaveRepository.LeaveByIdAsync(Convert.ToInt32(leaveResponse.CallbackId));
_logger.Debug("UpdateLeaveAsync leave applied by : " + leave.EmployeeId);
ApplicationUser user = await _userManagerRepository.FirstOrDefaultAsync(x => x.Id == leave.EmployeeId);
_logger.Debug("UpdateLeaveAsync User name : " + user.UserName);
SlackUserDetailAc slackUser = await _slackUserRepository.GetByIdAsync(user.SlackUserId);
_logger.Debug("UpdateLeaveAsync User slack name : " + slackUser.Name);
ApplicationUser updaterUser = await _userManagerRepository.FirstOrDefaultAsync(x => x.SlackUserId == leaveResponse.User.Id);
if (updaterUser != null)
{
_logger.Debug("UpdateLeaveAsync User want to update the leave : " + updaterUser.UserName);
// only pending status can be modified
if (leave.Status == Condition.Pending)
{
if (leaveResponse.Actions[0].Value == _stringConstant.Approved)
{
leave.Status = Condition.Approved;
}
else
{
leave.Status = Condition.Rejected;
}
await _leaveRepository.UpdateLeaveAsync(leave);
_logger.Debug("UpdateLeaveAsync leave updated successfully");
_logger.Debug("Leave details : " + leave.ToString());
replyText = string.Format(_stringConstant.CasualLeaveUpdateMessageForUser,
leave.Id, leave.FromDate.ToShortDateString(), leave.EndDate.Value.ToShortDateString(),
leave.Reason, leave.Status, leaveResponse.User.Name);
_logger.Debug("Reply text to user : "******"UpdateLeaveAsync user incoming webhook is null : " + string.IsNullOrEmpty(incomingWebHook.IncomingWebHookUrl));
// Used to send slack message to the user about leave updation
_logger.Debug("UpdateLeaveAsync Client repository - UpdateMessageAsync");
await _clientRepository.UpdateMessageAsync(incomingWebHook.IncomingWebHookUrl, replyText);
_logger.Debug("Creating Email object");
// Used to send email to the user about leave updation
EmailApplication email = new EmailApplication();
email.To = new List <string>();
email.Body = _emailTemplateRepository.EmailServiceTemplateLeaveUpdate(leave);
_logger.Debug("Email body is null : " + email.Body);
email.From = updaterUser.Email;
_logger.Debug("Email from : " + email.From);
email.To.Add(user.Email);
_logger.Debug("Email from : " + email.To);
email.Subject = string.Format(_stringConstant.LeaveUpdateEmailStringFormat, _stringConstant.Leave, leave.Status);
replyText = string.Format(_stringConstant.ReplyTextForUpdateLeave, leave.Status, slackUser.Name,
leave.FromDate.ToShortDateString(), leave.EndDate.Value.ToShortDateString(), leave.Reason,
leave.RejoinDate.Value.ToShortDateString());
_logger.Debug("Reply text to updator : " + replyText);
_logger.Debug("UpdateLeaveAsync Email sending");
_emailService.Send(email);
_logger.Debug("UpdateLeaveAsync Email successfully send");
}
else
{
_logger.Debug("UpdateLeaveAsync leave already updated");
replyText = string.Format(_stringConstant.AlreadyUpdatedMessage, leave.Status);
}
}
else
{
replyText = _stringConstant.YouAreNotInExistInOAuthServer;
}
}
catch (SmtpException ex)
{
replyText += string.Format(_stringConstant.ReplyTextForSMTPExceptionErrorMessage,
_stringConstant.ErrorWhileSendingEmail, ex.Message.ToString());
}
_logger.Debug("UpdateLeaveAsync Client Repository - SendMessageAsync");
// updating leave applied text of slack
await _clientRepository.SendMessageAsync(leaveResponse.ResponseUrl, replyText);
}
/// <summary>
/// Method to apply leave
/// </summary>
/// <param name="slackRequest">list of string contain leave slash command parameters</param>
/// <param name="leave">leave slash command</param>
/// <param name="accessToken">User's access token</param>
/// <returns>Reply text to be send</returns>
private async Task <string> LeaveApplyAsync(List <string> slackRequest, SlashCommand leave, string accessToken, string userId)
{
try
{
LeaveType leaveType;
DateTime startDate, endDate, reJoinDate;
User user = new User();
string dateFormat = Thread.CurrentThread.CurrentCulture.DateTimeFormat.ShortDatePattern;
_logger.Debug("LeaveApplyAsync Date format of leave command : " + dateFormat);
_logger.Debug("LeaveApplyAsync Current Culture info : " + Thread.CurrentThread.CurrentCulture.DisplayName);
// checking whether string can convert to date of independent culture or not, if return true then further process will be conduct
bool startDateConvertorResult = DateTime.TryParseExact(slackRequest[3], dateFormat, CultureInfo.InvariantCulture,
DateTimeStyles.None, out startDate);
if (startDateConvertorResult)
{
user = await _oauthCallsRepository.GetUserByUserIdAsync(userId, accessToken);
LeaveRequest leaveRequest = new LeaveRequest();
// Method to check leave's start date is not beyond today. Back date checking
bool validStartDate = LeaveStartDateValid(startDate);
if (validStartDate)
{
// checking whether string can convert to leave type or not, if return true then further process will be conduct
bool leaveTypeConvertorResult = Enum.TryParse(slackRequest[1], out leaveType);
if (leaveTypeConvertorResult)
{
// converting string to leave type of indian culture
switch (leaveType)
{
case LeaveType.cl:
{
_logger.Debug("LeaveApplyAsync Casual leave");
// checking whether string can convert to date of indian culture or not, if return true then further process will be conduct
bool endDateConvertorResult = DateTime.TryParseExact(slackRequest[4], dateFormat,
CultureInfo.InvariantCulture, DateTimeStyles.None, out endDate);
bool reJoinDateConvertorResult = DateTime.TryParseExact(slackRequest[5], dateFormat,
CultureInfo.InvariantCulture, DateTimeStyles.None, out reJoinDate);
if (endDateConvertorResult && reJoinDateConvertorResult)
{
// Method to check leave's end date is not beyond start date and re-join date is not beyond end date
bool validDate = ValidDateTimeForLeave(startDate, endDate, reJoinDate);
if (validDate)
{
// get user details from oAuth server
leaveRequest.EndDate = endDate;
leaveRequest.RejoinDate = reJoinDate;
leaveRequest.Status = Condition.Pending;
leaveRequest.Type = leaveType;
leaveRequest.Reason = slackRequest[2];
leaveRequest.FromDate = startDate;
leaveRequest.CreatedOn = DateTime.UtcNow;
// if user doesn't exist in OAuth server then user can't apply leave
if (user.Id != null)
{
_logger.Debug("LeaveApplyAsync leave apply user name : " + user.UserName);
// Method to check more than one leave cannot be applied on that date
validDate = await LeaveDateDuplicate(user.Id, startDate, endDate);
if (!validDate)
{
leaveRequest.EmployeeId = user.Id;
await _leaveRepository.ApplyLeaveAsync(leaveRequest);
_logger.Debug("LeaveApplyAsync Leave applied sucessfully");
replyText = _attachmentRepository.ReplyText(leave.Username, leaveRequest);
_logger.Debug("LeaveApplyAsync Client Repository - SendMessageWithAttachmentIncomingWebhookAsync");
// method to send slack notification and email to team leaders and management
await _clientRepository.SendMessageWithAttachmentIncomingWebhookAsync(leaveRequest,
accessToken, replyText, user.Id);
}
else
{
replyText = _stringConstant.LeaveAlreadyExistOnSameDate;
}
}
else
{
// if user doesn't exist in OAuth server then user can't apply leave, will get this message
replyText = _stringConstant.SorryYouCannotApplyLeave;
}
}
else
{
replyText = _stringConstant.InValidDateErrorMessage;
}
}
else
{
// if date is not proper than date format error message will be send to user
replyText = string.Format(_stringConstant.DateFormatErrorMessage, dateFormat);
}
}
break;
case LeaveType.sl:
{
_logger.Debug("LeaveApplyAsync Sick leave");
bool isAdmin = false;
User newUser = new User();
if (slackRequest.Count > 4)
{
isAdmin = await _oauthCallsRepository.UserIsAdminAsync(userId, accessToken);
_logger.Debug("LeaveApplyAsync User is admin : " + isAdmin);
if (isAdmin)
{
_logger.Debug("LeaveApplyAsync Sick Leave applying for other");
SlackUserDetailAc slackUser = await _slackUserRepository.GetBySlackNameAsync(slackRequest[4]);
// get user details from oAuth server for other user
var newUserDetails = await _userManagerRepository.FirstOrDefaultAsync(x => x.SlackUserId == slackUser.UserId);
newUser = await _oauthCallsRepository.GetUserByUserIdAsync(newUserDetails.Id, accessToken);
}
else
{
replyText = _stringConstant.AdminErrorMessageApplySickLeave;
}
}
else
{
_logger.Debug("LeaveApplyAsync Sick Leave applying for own");
// get user details from oAuth server for own
newUser = await _oauthCallsRepository.GetUserByUserIdAsync(userId, accessToken);
leaveRequest.EndDate = startDate;
leaveRequest.RejoinDate = startDate.AddDays(1);
}
leaveRequest.Status = Condition.Approved;
leaveRequest.Type = leaveType;
leaveRequest.Reason = slackRequest[2];
leaveRequest.FromDate = startDate;
leaveRequest.CreatedOn = DateTime.UtcNow;
// if user doesn't exist in OAuth server then user can't apply leave
if (newUser.Id != null)
{
// Method to check more than one leave cannot be applied on that date
bool validDate = await LeaveDateDuplicate(newUser.Id, startDate, null);
if (!validDate)
{
leaveRequest.EmployeeId = newUser.Id;
await _leaveRepository.ApplyLeaveAsync(leaveRequest);
_logger.Debug("LeaveApplyAsync Leave applied successfully");
replyText = _attachmentRepository.ReplyTextSick(newUser.FirstName, leaveRequest);
_logger.Debug("LeaveApplyAsync Client Repository - SendMessageWithoutButtonAttachmentIncomingWebhookAsync");
await _clientRepository.SendMessageWithoutButtonAttachmentIncomingWebhookAsync(leaveRequest,
accessToken, replyText, newUser.Id);
if (isAdmin)
{
_logger.Debug("LeaveApplyAsync Client Repository - SendSickLeaveMessageToUserIncomingWebhookAsync");
await _clientRepository.SendSickLeaveMessageToUserIncomingWebhookAsync(leaveRequest,
user.Email, replyText, newUser);
}
}
else
{
replyText = _stringConstant.LeaveAlreadyExistOnSameDate;
}
}
else
{
// if user doesn't exist in OAuth server then user can't apply leave, will get this message
replyText += _stringConstant.SorryYouCannotApplyLeave;
}
}
break;
}
}
else
{
// if leave type is not proper than not of leave type format error message will be send to user
replyText = _stringConstant.NotTypeOfLeave;
}
}
else
{
replyText = _stringConstant.BackDateErrorMessage;
}
}
else
{
// if date is not proper than date format error message will be send to user
replyText = string.Format(_stringConstant.DateFormatErrorMessage, dateFormat);
}
}
catch (SmtpException ex)
{
// error message will be send to email. But leave will be applied
replyText = string.Format(_stringConstant.ReplyTextForSMTPExceptionErrorMessage,
_stringConstant.ErrorWhileSendingEmail, ex.Message.ToString());
}
return(replyText);
}
