/// <summary>
/// It is called when the message is "list links","link "project"" or "unlink "project"" - JJ
/// </summary>
/// <param name="slackUserId">UserId of slack user</param>
/// <param name="slackChannel">slack channel from which message is send</param>
/// <param name="message">message from slack</param>
/// <returns>appropriate message</returns>
public async Task <string> ProcessSetUpMessagesAsync(string slackUserId, SlackChannelDetails slackChannel, string message)
{
if (String.Compare(message, _stringConstant.ListLinks, StringComparison.OrdinalIgnoreCase) == 0)
{
return(await ListLinkAsync(slackUserId));
}
else
{
string[] messageArray = message.Split(null);
int messageLength = message.Length - 1;
int first = message.IndexOf('"') + 1; //first index of ".
int last = message.IndexOf('"', message.IndexOf('"') + 1); //last index of "
int projectNameStartIndex = messageArray[0].Length + 2; // index from where the name of the project starts
if (messageLength == last && first == projectNameStartIndex)
{
//fetch the project name from the message string
string name = message.Substring(first, last - first);
if (string.IsNullOrEmpty(name)) // ex. link ""
{
return(null); // it will be considered as a normal message
}
return(await ProcessCommandsAsync(slackUserId, slackChannel.ChannelId, name, messageArray[0]));
}
else
{
if (slackChannel.ProjectId != null)
{
return(null);
}
return(_stringConstant.ProjectChannelNotLinked);
}
}
}
/// <summary>
/// Used to link Slack Channel to OAuth Project - JJ
/// </summary>
/// <param name="slackChannelId">slack channel id from which message is send</param>
/// <param name="givenProjectName">the project name mentioned in the slack message</param>
/// <param name="project">OAuth Project of the given name</param>
/// <returns>status message</returns>
private async Task <string> LinkAsync(string slackChannelId, string givenProjectName, ProjectAc project)
{
if (project.IsActive)
{
SlackChannelDetails alreadyLinkedChannel = await _slackChannelRepository.FetchChannelByProjectIdAsync(project.Id);
if (alreadyLinkedChannel == null)
{
//add the project id to the slack channel
SlackChannelDetails slackChannel = await _slackChannelRepository.GetByIdAsync(slackChannelId);
if (slackChannel.ProjectId == null)
{
_logger.Debug("\nLinkAsync method : not linked to any project yet\n");
slackChannel.ProjectId = project.Id;
await _slackChannelRepository.UpdateSlackChannelAsync(slackChannel);
return(string.Format(_stringConstant.ProjectLinked, givenProjectName, slackChannel.Name));
}
else
{
return(string.Format(_stringConstant.UnLinkFirst, givenProjectName));
}
}
else
{
return(_stringConstant.AlreadyLinked);
}
}
else
{
return(_stringConstant.InActiveProject);
}
}
/// <summary>
/// Used to add channel manually by command "add channel channelname". - JJ
/// </summary>
/// <param name="slackChannelName">slack channel name from which message is send</param>
/// <param name="slackChannelId">slack channel id from which message is send</param>
/// <param name="slackUserId">slack user id of interacting user</param>
/// <returns>status message</returns>
public async Task <string> AddChannelManuallyAsync(string slackChannelName, string slackChannelId, string slackUserId)
{
//Checks whether channelId starts with "G" or "C". This is done inorder to make sure that only gruops or channels are added manually
if (IsPrivateChannel(slackChannelId))
{
var accessToken = await GetAccessToken(slackUserId);
if (accessToken != null)
{
SlackChannelDetails slackChannelDetails = new SlackChannelDetails();
slackChannelDetails.ChannelId = slackChannelId;
slackChannelDetails.CreatedOn = DateTime.UtcNow;
slackChannelDetails.Deleted = false;
slackChannelDetails.Name = slackChannelName;
await _slackChannelRepository.AddSlackChannelAsync(slackChannelDetails);
return(_stringConstant.ChannelAddSuccess);
}
else
{
// if user doesn't exist then this message will be shown to user
return(_stringConstant.YouAreNotInExistInOAuthServer);
}
}
else
{
return(_stringConstant.OnlyPrivateChannel);
}
}
public async Task GetByIdFalseAsync()
{
await _slackChannelRepository.AddSlackChannelAsync(slackChannelDetails);
SlackChannelDetails slackChannel = await _slackChannelRepository.GetByIdAsync(_stringConstant.ChannelIdForTest);
Assert.NotEqual(slackChannel.ChannelId, _stringConstant.TeamLeaderIdForTest);
}
public async Task FetchChannelByProjectIdAsync()
{
slackChannelDetails.ProjectId = 1;
await _slackChannelRepository.AddSlackChannelAsync(slackChannelDetails);
SlackChannelDetails slackChannel = await _slackChannelRepository.FetchChannelByProjectIdAsync((int)slackChannelDetails.ProjectId);
Assert.Equal(slackChannel.Name, slackChannelDetails.Name);
}
/// <summary>
/// Method to delete slack channel by their slack channel id - JJ
/// </summary>
/// <param name="slackChannelId">Id of slack channel</param>
public async Task DeleteChannelAsync(string slackChannelId)
{
SlackChannelDetails channel = await GetByIdAsync(slackChannelId);
if (channel != null)
{
_slackChannelDetailsRepository.Delete(channel.Id);
await _slackChannelDetailsRepository.SaveChangesAsync();
}
}
public async Task DeleteChannelAsync()
{
await _slackChannelRepository.AddSlackChannelAsync(slackChannelDetails);
await _slackChannelRepository.DeleteChannelAsync(slackChannelDetails.ChannelId);
SlackChannelDetails slackChannel = await _slackChannelRepository.GetByIdAsync(slackChannelDetails.ChannelId);
Assert.Null(slackChannel);
}
public async Task UpdateSlackChannelAsync()
{
await _slackChannelRepository.AddSlackChannelAsync(slackChannelDetails);
slackChannelDetails.Name = _stringConstant.ChannelName;
await _slackChannelRepository.UpdateSlackChannelAsync(slackChannelDetails);
SlackChannelDetails slackChannel = await _slackChannelRepository.GetByIdAsync(_stringConstant.ChannelIdForTest);
Assert.Equal(slackChannel.Name, _stringConstant.ChannelName);
}
/// <summary>
/// Reads the JSON representation of the object. - JJ
/// </summary>
/// <param name="reader">The Newtonsoft.Json.JsonReader to read from</param>
/// <param name="objectType">Type of the object</param>
/// <param name="existingValue">The existing value of object being read</param>
/// <param name="serializer">The calling serializer</param>
/// <returns>The object value</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JToken token = JToken.Load(reader);
if (token.Type == JTokenType.Object)
{
return(token.ToObject <SlackChannelDetails>());
}
else
{
SlackChannelDetails result = new SlackChannelDetails();
result.ChannelId = (string)token;
return(result);
}
}
/// <summary>
/// Used to add channel manually by command "add channel channelname"
/// </summary>
/// <param name="channelName"></param>
/// <param name="channelId"></param>
/// <param name="username"></param>
/// <returns>status message</returns>
private async Task <string> AddChannelManually(string channelName, string username, string channelId)
{
string returnMsg = string.Empty;
//Checks whether channelId starts with "G". This is done inorder to make sure that only private channels are added manually
if (IsPrivateChannel(channelId))
{
// getting user name from user's slack name
var applicationUser = _applicationUser.FirstOrDefault(x => x.SlackUserName == username);
// getting access token for that user
if (applicationUser != null)
{
// get access token of user for promact oauth server
string accessToken = await _attachmentRepository.AccessToken(applicationUser.UserName);
//get the project details of the given channel name
ProjectAc project = await _projectUser.GetProjectDetails(channelName, accessToken);
//add channel details only if the channel has been registered as project in OAuth server
if (project != null && project.Id > 0)
{
SlackChannelDetails channel = new SlackChannelDetails();
channel.ChannelId = channelId;
channel.CreatedOn = DateTime.UtcNow;
channel.Deleted = false;
channel.Name = channelName;
_slackChannelRepository.AddSlackChannel(channel);
returnMsg = _stringConstant.ChannelAddSuccess;
}
else
{
returnMsg = _stringConstant.ProjectNotInOAuth;
}
}
else
{
// if user doesn't exist then this message will be shown to user
returnMsg = _stringConstant.YouAreNotInExistInOAuthServer;
}
}
else
{
return(_stringConstant.OnlyPrivateChannel);
}
return(returnMsg);
}
/// <summary>
/// Method to update slack channel table when a channel is added or updated in team.
/// </summary>
/// <param name="slackEvent"></param>
public async Task SlackChannelAddAsync(SlackEventApiAC slackEvent)
{
SlackChannelDetails channel = await _slackChannelDetails.FirstOrDefaultAsync(x => x.ChannelId == slackEvent.Event.Channel.ChannelId);
if (channel == null)
{
slackEvent.Event.Channel.CreatedOn = DateTime.UtcNow;
_slackChannelDetails.Insert(slackEvent.Event.Channel);
await _slackChannelDetails.SaveChangesAsync();
}
else
{
channel.Name = slackEvent.Event.Channel.Name;
_slackChannelDetails.Update(channel);
await _slackChannelDetails.SaveChangesAsync();
}
}
/// <summary>
/// Add slack channel details to the database - JJ
/// </summary>
/// <param name="slackChannelDetails">Slack channel details obtained from slack</param>
/// <returns></returns>
private async Task AddChannelGroupAsync(SlackChannelDetails slackChannelDetails)
{
SlackChannelDetails slackChannel = await _slackChannelDetails.FirstOrDefaultAsync(x => x.ChannelId == slackChannelDetails.ChannelId);
if (slackChannel == null)
{
if (!slackChannelDetails.Deleted)
{
slackChannelDetails.CreatedOn = DateTime.UtcNow;
await _slackChannelRepository.AddSlackChannelAsync(slackChannelDetails);
}
}
else
{
slackChannel.Name = slackChannelDetails.Name;
await _slackChannelRepository.UpdateSlackChannelAsync(slackChannel);
}
}
/// <summary>
/// Used to unlink Slack Channel from OAuth Project - JJ
/// </summary>
/// <param name="slackChannelId">slack channel id from which message is send</param>
/// <param name="givenProjectName">the project name mentioned in the slack message</param>
/// <param name="project">OAuth Project of the given name</param>
/// <returns>status message</returns>
private async Task <string> UnlinkAsync(string slackChannelId, string givenProjectName, ProjectAc project)
{
SlackChannelDetails slackChannel = await _slackChannelRepository.GetByIdAsync(slackChannelId);
if (slackChannel.ProjectId == null)
{
return(string.Format(_stringConstant.NotLinkedYet, givenProjectName));
}
else
{
if (slackChannel.ProjectId == project.Id)
{
_logger.Debug("\nUnLinkAsync method : matching project found\n");
slackChannel.ProjectId = null;
await _slackChannelRepository.UpdateSlackChannelAsync(slackChannel);
return(string.Format(_stringConstant.UnlinkedSuccessfully, givenProjectName, slackChannel.Name));
}
else
{
return(string.Format(_stringConstant.NotLinkedToChannel, givenProjectName));
}
}
}
/// <summary>
/// Method to add slack channel
/// </summary>
/// <param name="slackChannelDetails"></param>
public void AddSlackChannel(SlackChannelDetails slackChannelDetails)
{
_slackChannelDetailsContext.Insert(slackChannelDetails);
}
/// <summary>
/// Method to add slack channel. - JJ
/// </summary>
/// <param name="slackChannelDetails">object of SlackChannelDetails</param>
public async Task AddSlackChannelAsync(SlackChannelDetails slackChannelDetails)
{
_slackChannelDetailsRepository.Insert(slackChannelDetails);
await _slackChannelDetailsRepository.SaveChangesAsync();
}
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 channel information by their slack channel id - JJ
/// </summary>
/// <param name="slackChannelId">Id of slack channel</param>
/// <returns>object of SlackChannelDetails</returns>
public async Task <SlackChannelDetails> GetByIdAsync(string slackChannelId)
{
SlackChannelDetails channel = await _slackChannelDetailsRepository.FirstOrDefaultAsync(x => x.ChannelId == slackChannelId);
return(channel);
}
/// <summary>
/// Method to update slack channel details - JJ
/// </summary>
/// <param name="slackChannelDetails">object of SlackChannelDetails</param>
public async Task UpdateSlackChannelAsync(SlackChannelDetails slackChannelDetails)
{
_slackChannelDetailsRepository.Update(slackChannelDetails);
await _slackChannelDetailsRepository.SaveChangesAsync();
}
/// <summary>
/// Method to add/update Slack Users,channels and groups information
/// </summary>
/// <param name="code"></param>
/// <returns></returns>
public async Task AddSlackUserInformation(string code)
{
var slackOAuthRequest = string.Format("?client_id={0}&client_secret={1}&code={2}&pretty=1", _envVariableRepository.SlackOAuthClientId, _envVariableRepository.SlackOAuthClientSecret, code);
var slackOAuthResponse = await _httpClientRepository.GetAsync(_stringConstant.OAuthAcessUrl, slackOAuthRequest, null);
var slackOAuth = JsonConvert.DeserializeObject <SlackOAuthResponse>(slackOAuthResponse);
var detailsRequest = string.Format("?token={0}&pretty=1", slackOAuth.AccessToken);
var userDetailsResponse = await _httpClientRepository.GetAsync(_stringConstant.SlackUserListUrl, detailsRequest, null);
var slackUsers = JsonConvert.DeserializeObject <SlackUserResponse>(userDetailsResponse);
if (slackUsers.Ok)
{
foreach (var user in slackUsers.Members)
{
if (!user.Deleted)
{
_slackUserRepository.AddSlackUser(user);
}
}
}
else
{
throw new SlackAuthorizeException(_stringConstant.SlackAuthError + slackUsers.ErrorMessage);
}
var channelDetailsResponse = await _httpClientRepository.GetAsync(_stringConstant.SlackChannelListUrl, detailsRequest, null);
var channels = JsonConvert.DeserializeObject <SlackChannelResponse>(channelDetailsResponse);
if (channels.Ok)
{
foreach (var channel in channels.Channels)
{
SlackChannelDetails slackChannel = _slackChannelDetails.FirstOrDefault(x => x.ChannelId == channel.ChannelId);
if (slackChannel == null)
{
if (!channel.Deleted)
{
channel.CreatedOn = DateTime.UtcNow;
_slackChannelDetails.Insert(channel);
}
}
else
{
slackChannel.Name = channel.Name;
_slackChannelDetails.Update(slackChannel);
}
}
}
else
{
throw new SlackAuthorizeException(_stringConstant.SlackAuthError + channels.ErrorMessage);
}
var groupDetailsResponse = await _httpClientRepository.GetAsync(_stringConstant.SlackGroupListUrl, detailsRequest, null);
var groups = JsonConvert.DeserializeObject <SlackGroupDetails>(groupDetailsResponse);
if (groups.Ok)
{
foreach (var channel in groups.Groups)
{
SlackChannelDetails slackChannel = _slackChannelDetails.FirstOrDefault(x => x.ChannelId == channel.ChannelId);
if (slackChannel == null)
{
if (!channel.Deleted)
{
channel.CreatedOn = DateTime.UtcNow;
_slackChannelDetails.Insert(channel);
}
}
else
{
slackChannel.Name = channel.Name;
_slackChannelDetails.Update(slackChannel);
}
}
}
else
{
throw new SlackAuthorizeException(_stringConstant.SlackAuthError + groups.ErrorMessage);
}
}
