/// <summary>
/// Add Slack User Details to the database
/// </summary>
/// <param name="slackUserDetails"></param>
private void AddSlackUserDetail(SlackUserDetails slackUserDetails)
{
Mapper.Initialize(cfg => cfg.CreateMap <SlackUserDetails, SlackUserDetails>()
.ForMember(des => des.Title,
opt => opt.MapFrom(src => src.Profile.Title)
)
.ForMember(des => des.Email,
opt => opt.MapFrom(src => src.Profile.Email)
)
.ForMember(des => des.Skype,
opt => opt.MapFrom(src => src.Profile.Skype)
)
.ForMember(des => des.LastName,
opt => opt.MapFrom(src => src.Profile.LastName)
)
.ForMember(des => des.FirstName,
opt => opt.MapFrom(src => src.Profile.FirstName)
)
.ForMember(des => des.Phone,
opt => opt.MapFrom(src => src.Profile.Phone)
)
);
// Perform mapping
slackUserDetails = Mapper.Map(slackUserDetails, slackUserDetails);
slackUserDetails.CreatedOn = DateTime.UtcNow;
_slackUserDetails.Insert(slackUserDetails);
}
/// <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>
/// Add Slack User Details to the database - JJ
/// </summary>
/// <param name="slackUserDetails">slack user details. Object of SlackUserDetails</param>
private async Task AddSlackUserDetailAsync(SlackUserDetails slackUserDetails)
{
// Perform mapping
slackUserDetails = _mapper.Map <SlackUserDetails>(slackUserDetails);
slackUserDetails.CreatedOn = DateTime.UtcNow;
_slackUserDetailsRepository.Insert(slackUserDetails);
await _slackUserDetailsRepository.SaveChangesAsync();
}
/// <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);
}
/// <summary>
/// Method to update slack user table when there is any changes in slack
/// </summary>
/// <param name="slackEvent"></param>
public async Task SlackEventUpdateAsync(SlackEventApiAC slackEvent)
{
SlackUserDetails user = await _slackUserDetailsRepository.FirstOrDefaultAsync(x => x.UserId == slackEvent.Event.User.UserId);
if (user == null)
{
await _slackUserRepository.AddSlackUserAsync(slackEvent.Event.User);
}
}
/// <summary>
/// Method to update slack user
/// </summary>
/// <param name="slackUserDetails"></param>
public void UpdateSlackUser(SlackUserDetails slackUserDetails)
{
if (slackUserDetails.IsBot || slackUserDetails.Name == _stringConstant.SlackBotStringName)
{
UpdateSlackBotUser(slackUserDetails);
}
else
{
UpdateSlackUserDetail(slackUserDetails);
}
}
/// <summary>
/// Method to add/update slack user
/// </summary>
/// <param name="slackUserDetails">slack user details. Object of SlackUserDetails</param>
public async Task AddSlackUserAsync(SlackUserDetails slackUserDetails)
{
SlackUserDetails slackUser = await _slackUserDetailsRepository.FirstOrDefaultAsync(x => x.UserId == slackUserDetails.UserId);
if (slackUser == null)
{
if (!slackUserDetails.Deleted)
{
//Added to database only if the user is not deleted
await AddSlackUserDetailAsync(slackUserDetails);
}
}
else
{
await UpdateSlackUserAsync(slackUserDetails);
}
}
private void UpdateSlackUserDetail(SlackUserDetails slackUserDetails)
{
var user = _slackUserDetails.FirstOrDefault(x => x.UserId == slackUserDetails.UserId);
if (user != null)
{
Mapper.Initialize(cfg => cfg.CreateMap <SlackUserDetails, SlackUserDetails>()
.ForMember(des => des.Id, opt =>
{
opt.UseDestinationValue();
opt.Ignore();
})
.ForMember(des => des.CreatedOn, opt =>
{
opt.UseDestinationValue();
opt.Ignore();
})
.ForMember(des => des.Title,
opt => opt.MapFrom(src => src.Profile.Title)
)
.ForMember(des => des.Email,
opt => opt.MapFrom(src => src.Profile.Email)
)
.ForMember(des => des.Skype,
opt => opt.MapFrom(src => src.Profile.Skype)
)
.ForMember(des => des.LastName,
opt => opt.MapFrom(src => src.Profile.LastName)
)
.ForMember(des => des.FirstName,
opt => opt.MapFrom(src => src.Profile.FirstName)
)
.ForMember(des => des.Phone,
opt => opt.MapFrom(src => src.Profile.Phone)
)
);
// Perform mapping
user = Mapper.Map(slackUserDetails, user);
_slackUserDetails.Update(user);
}
else
{
throw new SlackUserNotFoundException(_stringConstant.UserNotFound);
}
}
/// <summary>
/// Method to update slack user. - JJ
/// </summary>
/// <param name="slackUserDetails">slack user details. Object of SlackUserDetails</param>
public async Task UpdateSlackUserAsync(SlackUserDetails slackUserDetails)
{
SlackUserDetails user = await _slackUserDetailsRepository.FirstOrDefaultAsync(x => x.UserId == slackUserDetails.UserId);
if (slackUserDetails.Deleted)
{
//delete the deleted user from database
_slackUserDetailsRepository.Delete(user.Id);
await _slackUserDetailsRepository.SaveChangesAsync();
}
else
{
// Perform mapping
user = _mapper.Map(slackUserDetails, user);
_slackUserDetailsRepository.Update(user);
await _slackUserDetailsRepository.SaveChangesAsync();
}
}
/// <summary>
/// Method to add slack user
/// </summary>
/// <param name="slackUserDetails"></param>
public void AddSlackUser(SlackUserDetails slackUserDetails)
{
SlackUserDetails slackUser = _slackUserDetails.FirstOrDefault(x => x.UserId == slackUserDetails.UserId);
SlackBotUserDetail slackBotUser = _slackUserBotDetails.FirstOrDefault(x => x.UserId == slackUserDetails.UserId);
if (slackUser == null && slackBotUser == null)
{
if (slackUserDetails.IsBot || slackUserDetails.Name == _stringConstant.SlackBotStringName)
{
AddSlackBotUserDetail(slackUserDetails);
}
else
{
AddSlackUserDetail(slackUserDetails);
}
}
else
{
UpdateSlackUser(slackUserDetails);
}
}
/// <summary>
/// Add slack BotUser details to the database
/// </summary>
/// <param name="slackUserDetails"></param>
private void AddSlackBotUserDetail(SlackUserDetails slackUserDetails)
{
SlackBotUserDetail slackUserBotDetail = new SlackBotUserDetail();
Mapper.Initialize(cfg => cfg.CreateMap <SlackUserDetails, SlackBotUserDetail>()
.ForMember(des => des.FirstName,
opt => opt.MapFrom(src => src.Profile.FirstName)
)
.ForMember(des => des.LastName,
opt => opt.MapFrom(src => src.Profile.LastName)
)
.ForMember(des => des.BotId,
opt => opt.MapFrom(src => src.Profile.BotId)
)
);
// Perform mapping
slackUserBotDetail = Mapper.Map(slackUserDetails, slackUserBotDetail);
slackUserBotDetail.CreatedOn = DateTime.UtcNow;
_slackUserBotDetails.Insert(slackUserBotDetail);
}
private void UpdateSlackBotUser(SlackUserDetails slackUserDetails)
{
var botUser = _slackUserBotDetails.FirstOrDefault(x => x.UserId == slackUserDetails.UserId);
if (botUser != null)
{
Mapper.Initialize(cfg => cfg.CreateMap <SlackUserDetails, SlackBotUserDetail>()
.ForMember(des => des.Id, opt =>
{
opt.UseDestinationValue();
opt.Ignore();
})
.ForMember(des => des.CreatedOn, opt =>
{
opt.UseDestinationValue();
opt.Ignore();
})
.ForMember(des => des.LastName,
opt => opt.MapFrom(src => src.Profile.LastName)
)
.ForMember(des => des.FirstName,
opt => opt.MapFrom(src => src.Profile.FirstName)
)
.ForMember(des => des.BotId,
opt => opt.MapFrom(src => src.Profile.BotId)
)
);
// Perform mapping
botUser = Mapper.Map(slackUserDetails, botUser);
_slackUserBotDetails.Update(botUser);
}
else
{
throw new SlackUserNotFoundException(_stringConstant.BotNotFound);
}
}
public async Task <string> ProcessMessages(string userId, string channelId, string message)
{
string replyText = string.Empty;
SlackUserDetails user = _slackUserDetails.GetById(userId);
SlackChannelDetails channel = _slackChannelRepository.GetById(channelId);
//the command is split to individual words
//commnads ex: "scrum time", "later @userId"
var messageArray = message.Split(null);
if (user != null && String.Compare(message, _stringConstant.ScrumHelp, true) == 0)
{
replyText = _stringConstant.ScrumHelpMessage;
}
else if (user != null && channel != null)
{
//commands could be"scrum time" or "scrum halt" or "scrum resume"
if (String.Compare(message, _stringConstant.ScrumTime, true) == 0 || String.Compare(message, _stringConstant.ScrumHalt, true) == 0 || String.Compare(message, _stringConstant.ScrumResume, true) == 0)
{
replyText = await Scrum(channel.Name, user.Name, messageArray[1].ToLower());
}
//a particular employee is on leave, getting marked as later or asked question again
//commands would be "leave @userId"
else if ((String.Compare(messageArray[0], _stringConstant.Leave, true) == 0) && messageArray.Length == 2)
{
int fromIndex = message.IndexOf("<@") + "<@".Length;
int toIndex = message.LastIndexOf(">");
if (toIndex > 0)
{
try
{
//the userId is fetched
string applicantId = message.Substring(fromIndex, toIndex - fromIndex);
//fetch the user of the given userId
SlackUserDetails applicant = _slackUserDetails.GetById(applicantId);
if (applicant != null)
{
string applicantName = applicant.Name;
replyText = await Leave(channel.Name, user.Name, applicantName);
}
else
{
replyText = _stringConstant.NotAUser;
}
}
catch (Exception)
{
replyText = _stringConstant.ScrumHelpMessage;
}
}
else
{
replyText = await AddScrumAnswer(user.Name, message, channel.Name);
}
}
//all other texts
else
{
replyText = await AddScrumAnswer(user.Name, message, channel.Name);
}
}
//If channel is not registered in the database
else if (user != null)
{
//If channel is not registered in the database and the command encountered is "add channel channelname"
if (channel == null && String.Compare(messageArray[0], _stringConstant.Add, true) == 0 && String.Compare(messageArray[1], _stringConstant.Channel, true) == 0)
{
replyText = AddChannelManually(messageArray[2], user.Name, channelId).Result;
}
else
{
replyText = _stringConstant.ChannelAddInstruction;
}
}
else if (user == null)
{
SlackBotUserDetail botUser = _slackBotUserDetail.FirstOrDefault(x => x.UserId == userId);
if (botUser == null)
{
replyText = _stringConstant.NoSlackDetails;
}
}
return(replyText);
}
/// <summary>
/// Method to get slack user information by their slack user id
/// </summary>
/// <param name="slackId"></param>
/// <returns>user</returns>
public SlackUserDetails GetById(string slackId)
{
SlackUserDetails user = _slackUserDetails.FirstOrDefault(x => x.UserId == slackId);
return(user);
}
/// <summary>
/// Method to add/update Slack User,channels and groups information
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public async Task AddSlackUserInformationAsync(string code)
{
string slackOAuthRequest = string.Format(_stringConstant.SlackOauthRequestUrl, _envVariableRepository.SlackOAuthClientId, _envVariableRepository.SlackOAuthClientSecret, code);
string slackOAuthResponse = await _httpClientService.GetAsync(_stringConstant.OAuthAcessUrl, slackOAuthRequest, null, _stringConstant.Bearer);
SlackOAuthResponse slackOAuth = JsonConvert.DeserializeObject <SlackOAuthResponse>(slackOAuthResponse);
_logger.Info("slackOAuth UserID" + slackOAuth.UserId);
bool checkUserIncomingWebHookExist = _incomingWebHookRepository.Any(x => x.UserId == slackOAuth.UserId);
if (!checkUserIncomingWebHookExist)
{
IncomingWebHook slackItem = new IncomingWebHook()
{
UserId = slackOAuth.UserId,
IncomingWebHookUrl = slackOAuth.IncomingWebhook.Url
};
_incomingWebHookRepository.Insert(slackItem);
await _incomingWebHookRepository.SaveChangesAsync();
}
string detailsRequest = string.Format(_stringConstant.SlackUserDetailsUrl, slackOAuth.AccessToken);
//get all the slack users of the team
string userDetailsResponse = await _httpClientService.GetAsync(_stringConstant.SlackUserListUrl, detailsRequest, null, _stringConstant.Bearer);
SlackUserResponse slackUsers = JsonConvert.DeserializeObject <SlackUserResponse>(userDetailsResponse);
if (slackUsers.Ok)
{
SlackUserDetails slackUserDetails = slackUsers.Members?.Find(x => x.UserId == slackOAuth.UserId);
_logger.Debug("slackUserDetails" + slackUserDetails.UserId);
if (!string.IsNullOrEmpty(slackUserDetails?.Profile?.Email))
{
//fetch the details of the user who is authenticated with Promact OAuth server with the given slack user's email
_logger.Debug("Profile Email" + slackUserDetails.Profile.Email);
ApplicationUser applicationUser = await _userManager.FindByEmailAsync(slackUserDetails.Profile.Email);
if (applicationUser != null)
{
_logger.Debug("slackUserDetails UserID" + slackUserDetails.UserId);
applicationUser.SlackUserId = slackUserDetails.UserId;
_logger.Debug("applicationUser SlackUserId" + applicationUser.SlackUserId);
var succeeded = await _userManager.UpdateAsync(applicationUser);
_logger.Debug("applicationUser Object:" + JsonConvert.SerializeObject(applicationUser));
_logger.Debug("Update Application User succeeded" + succeeded.Succeeded);
_logger.Debug("Update Application User Errors" + succeeded.Errors);
ApplicationUser testApllicationUser = await _userManager.FindByEmailAsync(applicationUser.Email);
_logger.Debug("Test Application Slcak UserId" + testApllicationUser.SlackUserId);
_logger.Debug("Test ApplicationUser Object:" + JsonConvert.SerializeObject(testApllicationUser));
await _slackUserRepository.AddSlackUserAsync(slackUserDetails);
_logger.Debug("Add Slack User Id Done");
//the public channels' details
string channelDetailsResponse = await _httpClientService.GetAsync(_stringConstant.SlackChannelListUrl, detailsRequest, null, _stringConstant.Bearer);
SlackChannelResponse channels = JsonConvert.DeserializeObject <SlackChannelResponse>(channelDetailsResponse);
if (channels.Ok)
{
_logger.Info("Channels error:" + channels.ErrorMessage);
foreach (var channel in channels.Channels)
{
_logger.Info("Channel:" + channel);
await AddChannelGroupAsync(channel);
}
}
else
{
throw new SlackAuthorizeException(_stringConstant.SlackAuthError + channels.ErrorMessage);
}
_logger.Info("Slack User Id : " + (await _userManager.FindByEmailAsync(applicationUser.Email)).SlackUserId);
//the public groups' details
string groupDetailsResponse = await _httpClientService.GetAsync(_stringConstant.SlackGroupListUrl, detailsRequest, null, _stringConstant.Bearer);
SlackGroupDetails groups = JsonConvert.DeserializeObject <SlackGroupDetails>(groupDetailsResponse);
_logger.Info("Groups:" + groups.ErrorMessage);
_logger.Debug("Slack User Id : " + (await _userManager.FindByEmailAsync(applicationUser.Email)).SlackUserId);
if (groups.Ok)
{
foreach (var channel in groups.Groups)
{
_logger.Info("Group:" + channel);
await AddChannelGroupAsync(channel);
_logger.Debug("Slack User Id : " + (await _userManager.FindByEmailAsync(applicationUser.Email)).SlackUserId);
}
}
else
{
throw new SlackAuthorizeException(_stringConstant.SlackAuthError + groups.ErrorMessage);
}
}
else
{
throw new SlackAuthorizeException(string.Format(_stringConstant.NotInSlackOrNotExpectedUser, slackUserDetails.Profile.Email));
}
}
else
{
throw new SlackAuthorizeException(_stringConstant.UserNotInSlack);
}
}
else
{
throw new SlackAuthorizeException(_stringConstant.SlackAuthError + slackUsers.ErrorMessage);
}
}
