/// <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); } }