/// <summary>
        /// Method to send request to update the redmine issue
        /// </summary>
        /// <param name="issueId">issue Id</param>
        /// <param name="redmineApiKey">redmine api key</param>
        /// <param name="issue">issue details</param>
        private async Task UpdateIssueAsync(int issueId, string redmineApiKey, PostRedmineResponse issue)
        {
            var updateRequestUrl = string.Format(_stringConstant.RedmineIssueUpdateUrl,
                                                 _stringConstant.RedmineBaseUrl, _stringConstant.IssueUrl, issueId);
            var issueInJsonText = JsonConvert.SerializeObject(issue);
            // To update issue in redmine
            var updateResult = await _httpClientService.PutAsync(updateRequestUrl, issueInJsonText,
                                                                 _stringConstant.JsonApplication, redmineApiKey, _stringConstant.RedmineApiKey);

            if (updateResult == null)
            {
                replyText = _stringConstant.ErrorInUpdateIssue;
            }
            else
            {
                replyText = string.Format(_stringConstant.IssueSuccessfullUpdated, issueId);
            }
        }
        /// <summary>
        /// Method to check the where issue exist or not to update if exist then exist
        /// </summary>
        /// <param name="isClose">update to close the issue</param>
        /// <param name="assignTo">update to assign the issue</param>
        /// <param name="issueStringId">issue id in string</param>
        /// <param name="userRedmineApiKey">redmine api key</param>
        private async Task UpdateByPropertyAsync(bool isClose, int assignTo, string issueStringId, string userRedmineApiKey)
        {
            int    issueId;
            string result;

            if (ToCheckIssueExistOrNot(issueStringId, userRedmineApiKey, out issueId, out result))
            {
                var response    = JsonConvert.DeserializeObject <RedmineResponseSingleProject>(result);
                var updateIssue = new PostRedmineResponse()
                {
                    Issue = new PostRedminIssue()
                    {
                        ProjectId   = response.Issue.Project.Id,
                        PriorityId  = (Priority)response.Issue.Priority.Id,
                        TrackerId   = (Tracker)response.Issue.Tracker.Id,
                        StatusId    = (Status)response.Issue.Status.Id,
                        Description = response.Issue.Description,
                        Subject     = response.Issue.Subject
                    }
                };
                // If true update assigneeTo
                if (isClose)
                {
                    updateIssue.Issue.AssignTo = response.Issue.AssignTo.Id;
                    updateIssue.Issue.StatusId = Status.Closed;
                }
                // else close the issue
                else
                {
                    updateIssue.Issue.AssignTo = assignTo;
                    updateIssue.Issue.StatusId = (Status)response.Issue.Status.Id;
                }
                // To update issue in redmine
                await UpdateIssueAsync(issueId, userRedmineApiKey, updateIssue);
            }
        }
        /// <summary>
        /// Method to create red mine issue
        /// </summary>
        /// <param name="user">user details</param>
        /// <param name="text">list of string containing parameter to create issue</param>
        private async Task CreateRedmineIssue(ApplicationUser user, List <string> text)
        {
            Priority priorityId;
            Status   statusId;
            Tracker  trackerId;

            if (CheckPriority(text[5], out priorityId) && CheckStatus(text[6], out statusId) && CheckTracker(text[7], out trackerId))
            {
                int projectId;
                if (int.TryParse(text[2], out projectId))
                {
                    // To get user Id
                    var redmineUserId = await GetUserRedmineIdByNameAsync(text[8], projectId, user.RedmineApiKey);

                    if (redmineUserId != 0)
                    {
                        var issue = new PostRedmineResponse()
                        {
                            Issue = new PostRedminIssue()
                            {
                                ProjectId   = projectId,
                                PriorityId  = priorityId,
                                TrackerId   = trackerId,
                                StatusId    = statusId,
                                Subject     = text[3],
                                Description = text[4],
                                AssignTo    = redmineUserId
                            }
                        };
                        var requestUrl = string.Format(_stringConstant.FirstAndSecondIndexStringFormat,
                                                       _stringConstant.RedmineBaseUrl, _stringConstant.RedmineIssueUrl);
                        var issueInJsonText = JsonConvert.SerializeObject(issue);
                        // Post call to create issue in redmine
                        var result = await _httpClientService.PostAsync(requestUrl, issueInJsonText,
                                                                        _stringConstant.JsonApplication, user.RedmineApiKey, _stringConstant.RedmineApiKey);

                        if (string.IsNullOrEmpty(result))
                        {
                            // If issue is not created in redmine
                            replyText = _stringConstant.ErrorInCreatingIssue;
                        }
                        else
                        {
                            // If issue is created on redmine
                            var createdIssue = JsonConvert.DeserializeObject <RedmineResponseSingleProject>(result);
                            replyText = string.Format(_stringConstant.IssueSuccessfullyCreatedMessage, createdIssue.Issue.IssueId);
                        }
                    }
                    else
                    {
                        // If user not found in redmine
                        replyText = string.Format(_stringConstant.NoUserFoundInProject, text[8], projectId);
                    }
                }
                else
                {
                    // If project Id is not valid, i.e., not a integer
                    replyText = _stringConstant.ProperProjectId;
                }
            }
        }