public IActionResult returnToIndex()
        {

            var role = HttpContext.Session.Get<RoleAssignment>("SelectedRole");
            var viewData = new DiagonizePageViewModel() { SelectedRole = role, DiagonizeQuery = new DiagonizeQuery() { StartDate = DateTime.Now.AddDays(-2), EndDate = DateTime.Now } };
            return View(viewData);
        }
 public IActionResult Index()
 {
     //var role = HttpContext.Session.Get<IEnumerable<RoleAssignment>>("WVDRoles").FirstOrDefault();
     var role = HttpContext.Session.Get<RoleAssignment>("SelectedRole");
     var viewData = new DiagonizePageViewModel() { SelectedRole = role, DiagonizeQuery = new DiagonizeQuery() { StartDate = DateTime.Now.AddDays(-2), EndDate = DateTime.Now } };
     return View(viewData);
 }
        public async Task<IActionResult> ClearFilter(DiagonizePageViewModel diagonizePageViewModel, string upn = null)
        {
            // diagonizePageViewModel.DiagonizeQuery.UPN = upn;
            // diagonizePageViewModel.DiagonizeQuery.ActivityOutcome= Convert.ToString(outcome);
            //HttpContext.Session.Remove("interval");
            //HttpContext. Session.Remove("outcome");
            if (diagonizePageViewModel.DiagonizeQuery == null)
            {
                diagonizePageViewModel.DiagonizeQuery = new DiagonizeQuery();
                diagonizePageViewModel.DiagonizeQuery.UPN = upn;

            }
            return await IssuesInterval(diagonizePageViewModel,null,null,upn);

        }
        public async Task <IActionResult> ClearFilter(DiagonizePageViewModel diagonizePageViewModel, string upn = null)
        {
            if (diagonizePageViewModel.DiagonizeQuery == null)
            {
                diagonizePageViewModel.DiagonizeQuery     = new DiagonizeQuery();
                diagonizePageViewModel.DiagonizeQuery.UPN = upn;
            }

            string outcome  = ActivityOutcome.All.ToString();
            string interval = startDateEnum.oneweekago.ToString();

            HttpContext.Session.Set <string>("SelectedInterval", interval);
            HttpContext.Session.Set <string>("SelectedOutcome", outcome);
            return(await IssuesInterval(diagonizePageViewModel, interval, outcome, upn));
        }
        public async Task <IActionResult> Index(DiagonizePageViewModel data)
        {
            var viewData = new DiagonizePageViewModel();

            if (ModelState.IsValid)
            {
                tenantGroupName = HttpContext.Session.Get <string>("SelectedTenantGroupName");
                tenant          = HttpContext.Session.Get <string>("SelectedTenantName");
                if (string.IsNullOrEmpty(tenantGroupName) || string.IsNullOrEmpty(tenant))
                {
                    return(RedirectToAction("Error", "Home", new ErrorDetails()
                    {
                        StatusCode = (int)HttpStatusCode.Forbidden, Message = "Invalid tenant group name or tenant name."
                    }));
                }
                else
                {
                    var refreshtoken = await HttpContext.GetTokenAsync("refresh_token").ConfigureAwait(false);

                    accessToken = _commonService.GetAccessTokenWVD(refreshtoken); //await HttpContext.GetTokenAsync("access_token");
                    string startDate, endDate = "";
                    if (data.DiagonizeQuery.StartDate == null)
                    {
                        startDate = $"{DateTime.Now.ToUniversalTime().AddDays(-7).ToString("yyyy-MM-dd")}T00:00:00Z";
                        endDate   = $"{DateTime.Now.ToUniversalTime().ToString("yyyy-MM-dd")}T00:00:00Z";
                    }
                    else
                    {
                        startDate = data.DiagonizeQuery.StartDate.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ"); //+"T00:00:00Z";
                        endDate   = data.DiagonizeQuery.EndDate.ToUniversalTime().ToString("yyyy-MM-ddTHH:mm:ssZ");   //+"T00: 00:00Z";
                    }



                    string activityoutcome = data.DiagonizeQuery.ActivityOutcome.ToString();
                    if (data.DiagonizeQuery.ActivityType == ActivityType.Management)
                    {
                        _logger.LogInformation($"Service call to get management activity details for selected tenant group {tenantGroupName} and tenant {tenant}");
                        //call from service layer
                        viewData.ManagementActivity = await _diagnozeService.GetManagementActivities(accessToken, data.DiagonizeQuery.UPN, tenantGroupName, tenant, startDate, endDate, activityoutcome).ConfigureAwait(false);

                        if (viewData.ManagementActivity?.Count > 0 && viewData.ManagementActivity[0].ErrorDetails != null)
                        {
                            _logger.LogError($"Error Occured : {viewData.ManagementActivity[0].ErrorDetails.Message}");
                            return(RedirectToAction("Error", "Home", new ErrorDetails()
                            {
                                StatusCode = (int)viewData.ManagementActivity[0].ErrorDetails.StatusCode, Message = "Access Denied!You are not authorized.Please contact system administrator"
                            }));
                        }
                        viewData.ActivityType = viewData.ManagementActivity?.Count() > 0 ? ActivityType.Management : ActivityType.None;
                    }
                    else if (data.DiagonizeQuery.ActivityType == ActivityType.Connection)
                    {
                        _logger.LogInformation($"Service Call  to get connection activity details for selected tenant group {tenantGroupName} and tenant {tenant}");

                        //call from service layer
                        viewData.ConnectionActivity = await _diagnozeService.GetConnectionActivities(accessToken, data.DiagonizeQuery.UPN, tenantGroupName, tenant, startDate, endDate, activityoutcome).ConfigureAwait(false);

                        if (viewData.ConnectionActivity?.Count > 0 && viewData.ConnectionActivity[0].ErrorDetails != null)
                        {
                            _logger.LogError($"Error Occured : {viewData.ConnectionActivity[0].ErrorDetails.Message}");
                            return(RedirectToAction("Error", "Home", new ErrorDetails()
                            {
                                StatusCode = (int)viewData.ConnectionActivity[0].ErrorDetails.StatusCode, Message = "Access Denied!You are not authorized.Please contact system administrator"
                            }));
                        }

                        viewData.ActivityType = viewData.ConnectionActivity?.Count() > 0 ? ActivityType.Connection : ActivityType.None;
                    }
                    else if (data.DiagonizeQuery.ActivityType == ActivityType.Feed)
                    {
                        _logger.LogInformation($"Service call to get feed activity details for selected tenant group {tenantGroupName} and tenant {tenant}");

                        viewData.FeedActivity = await _diagnozeService.GetFeedActivities(accessToken, data.DiagonizeQuery.UPN, tenantGroupName, tenant, startDate, endDate, activityoutcome).ConfigureAwait(false);

                        if (viewData.FeedActivity?.Count > 0 && viewData.FeedActivity[0].ErrorDetails != null)
                        {
                            _logger.LogError($"Error Occured : {viewData.FeedActivity[0].ErrorDetails.Message}");
                            return(RedirectToAction("Error", "Home", new ErrorDetails()
                            {
                                StatusCode = (int)viewData.FeedActivity[0].ErrorDetails.StatusCode, Message = viewData.FeedActivity[0].ErrorDetails.Message
                            }));
                        }
                        viewData.ActivityType = viewData.FeedActivity?.Count() > 0 ? ActivityType.Feed : ActivityType.None;
                    }
                }
            }
            HttpContext.Session.Set <DiagonizeQuery>("SearchQuery", data.DiagonizeQuery);
            viewData.DiagonizeQuery = data.DiagonizeQuery;
            return(View("SearchResults", viewData));
        }
        public async Task <IActionResult> IssuesInterval(DiagonizePageViewModel diagonizePageViewModel, string interval = null, string outcome = null, string upn = null)
        {
            //DiagonizePageViewModel diagonizePageViewModel = new DiagonizePageViewModel();
            // diagonizePageViewModel.DiagonizeQuery = new DiagonizeQuery();
            if (diagonizePageViewModel.DiagonizeQuery == null)
            {
                diagonizePageViewModel.DiagonizeQuery     = new DiagonizeQuery();
                diagonizePageViewModel.DiagonizeQuery.UPN = upn;
            }


            try
            {
                if (diagonizePageViewModel.DiagonizeQuery.UPN != null)
                {
                    if (!string.IsNullOrEmpty(interval))
                    {
                        HttpContext.Session.Set <string>("SelectedInterval", interval);
                    }
                    else
                    {
                        diagonizePageViewModel.DiagonizeQuery.StartDate = DateTime.Now.AddDays(-7);
                        diagonizePageViewModel.DiagonizeQuery.EndDate   = DateTime.Now;
                        interval = HttpContext.Session.Get <string>("SelectedInterval");
                    }

                    if (!string.IsNullOrEmpty(outcome))
                    {
                        HttpContext.Session.Set <string>("SelectedOutcome", outcome);
                    }
                    else
                    {
                        outcome = HttpContext.Session.Get <string>("SelectedOutcome");
                    }



                    diagonizePageViewModel.DiagonizeQuery.ActivityOutcome = outcome != null ? (ActivityOutcome)Enum.Parse(typeof(ActivityOutcome), outcome) : ActivityOutcome.All;
                    if (interval == startDateEnum.Lastonehour.ToString())
                    {
                        diagonizePageViewModel.DiagonizeQuery.StartDate = DateTime.Now.AddMinutes(-60);
                        diagonizePageViewModel.DiagonizeQuery.EndDate   = DateTime.Now;
                    }
                    else if (interval == startDateEnum.sixhoursago.ToString())
                    {
                        diagonizePageViewModel.DiagonizeQuery.StartDate = DateTime.Now.AddHours(-6);
                        diagonizePageViewModel.DiagonizeQuery.EndDate   = DateTime.Now;
                    }
                    else if (interval == startDateEnum.onedayago.ToString())
                    {
                        diagonizePageViewModel.DiagonizeQuery.StartDate = DateTime.Now.AddDays(-1);
                        diagonizePageViewModel.DiagonizeQuery.EndDate   = DateTime.Now;
                    }
                    else if (interval == startDateEnum.onweekago.ToString())
                    {
                        diagonizePageViewModel.DiagonizeQuery.StartDate = DateTime.Now.AddDays(-7);
                        diagonizePageViewModel.DiagonizeQuery.EndDate   = DateTime.Now;
                    }
                    return(await Index(diagonizePageViewModel));
                }
                else
                {
                    return(View("Index", diagonizePageViewModel));
                }
            }
            catch (Exception ex)
            {
                return(null);
            }
        }