public async Task <IActionResult> Refresh(RefreshViewModel model)
        {
            if (ModelState.IsValid)
            {
                UserToken token = await tokenRepository.FindOneAsync(
                    model.UserId, model.RefreshToken);

                if (token == null)
                {
                    return(Unauthorized());
                }

                // Old token has been expired
                token.Expired = true;
                tokenRepository.Update(token);

                // Issue a new token
                token = NewToken(token.UserId);
                tokenRepository.Add(token);
                tokenRepository.SaveChanges();

                return(Ok(BuildJwtResponse(token.UserId, token.Id)));
            }

            return(BadRequest("Could not refresh token"));
        }
        public Locator()
        {
            var ssidListViewModel = new SSIDListViewModel();

            this.SSIDListViewModel = ssidListViewModel;
            this.RefreshViewModel  = new RefreshViewModel(ssidListViewModel);
        }
        public async Task <IActionResult> RefreshToken([FromBody] RefreshViewModel refresh)
        {
            if (!ModelState.IsValid)
            {
                return(new BadResponseResult(ModelState));
            }
            var result = await _authService.GetRefreshTokenAsync(refresh.RefreshToken);

            return(new OkResponseResult(result));
        }
Exemple #4
0
        public async Task <IActionResult> RefreshTokens(RefreshViewModel model)
        {
            var response = await _authentication.RefreshTokensAsync(model);

            if (response != null)
            {
                return(Ok(response));
            }

            return(BadRequest());
        }
        public async Task <ActionResult <Response <Token> > > RefreshToken([FromBody] RefreshViewModel item)
        {
            try
            {
                var result = await _auth.RefreshToken(item.AccessToken, item.RefreshToken);

                return(StatusCode(result.Code, new Ack <Token>(result)));
            }
            catch (Exception)
            {
                return(StatusCode(520, new Ack <Token>(null, "Unknown error")));
            }
        }
Exemple #6
0
        public IActionResult Put([FromBody] RefreshViewModel viewModel)
        {
            var result = userService.Refresh(viewModel);

            if (result != null)
            {
                return(Ok(result));
            }
            else
            {
                return(Forbid());
            }
        }
Exemple #7
0
 private void ReadWriteRegistersUserControl_OnDataContextChanged(object sender, DependencyPropertyChangedEventArgs e)
 {
     if (e.OldValue is ViewModelManager vmmOld)
     {
         vmmOld.RefreshViewModel.RefreshLow -= this.Update;
     }
     if (e.NewValue is ViewModelManager vmm)
     {
         this.systemViewModel             = vmm.SystemViewModel;
         this.refreshViewModel            = vmm.RefreshViewModel;
         this.plottingViewModel           = vmm.PlottingViewModel;
         vmm.RefreshViewModel.RefreshLow += this.Update;
     }
 }
        void Construct()
        {
            BindingContext = new RefreshViewModel();

            var refreshView = new RefreshView
            {
                BackgroundColor = Color.Red,
                RefreshColor    = Color.Yellow
            };

            refreshView.SetBinding(RefreshView.CommandProperty, "RefreshCommand");
            refreshView.SetBinding(RefreshView.IsRefreshingProperty, "IsRefreshing");

            refreshView.On <WindowsOS>().SetRefreshPullDirection(RefreshPullDirection.BottomToTop);

            var listView = new ListView
            {
                ItemTemplate = new DataTemplate(() =>
                {
                    var stackLayout = new StackLayout
                    {
                        Orientation = StackOrientation.Horizontal
                    };

                    var boxView = new BoxView {
                        WidthRequest = 40
                    };
                    var infoLabel = new Label();

                    boxView.SetBinding(BoxView.ColorProperty, "Color");
                    infoLabel.SetBinding(Label.TextProperty, "Name");

                    stackLayout.Children.Add(boxView);
                    stackLayout.Children.Add(infoLabel);

                    return(new ViewCell {
                        View = stackLayout
                    });
                })
            };

            listView.SetBinding(ListView.ItemsSourceProperty, "Items");

            refreshView.Content = listView;

            Content = refreshView;
        }
Exemple #9
0
        public LoginResultViewModel Refresh(RefreshViewModel viewModel)
        {
            var user = context.Users.FirstOrDefault(u => u.RefreshTokens.Any(r => r.Token == viewModel.Token));

            if (user == null)
            {
                return(null);              // TODO: Error handling
            }
            var result = GetAccessToken(user);

            if (result != null)
            {
                user.RefreshTokens.Remove(user.RefreshTokens.FirstOrDefault(r => r.Token == viewModel.Token));
                context.SaveChanges();
            }

            return(result);
        }
Exemple #10
0
        public async Task <DefaultResponse> RefreshTokensAsync(RefreshViewModel model)
        {
            if (string.IsNullOrWhiteSpace(model.RefreshToken) || string.IsNullOrWhiteSpace(model.Fingerprint))
            {
                return(null);
            }

            var session = await _sessionContext.FirstOrDefaultAsync(s => s.RefreshToken == model.RefreshToken);

            if (session is null)
            {
                return(null);
            }

            if (session.ExpiresAt < DateTime.Now || session.Fingerprint != model.Fingerprint)
            {
                _sessionContext.Remove(session);
                await _context.SaveChangesAsync();

                return(null);
            }


            var user = await _userManager.FindByIdAsync(session.UserId.ToString());

            var accessToken = await GenerateAccessWithClaims(user);

            var refreshToken = await _tokenHandler.GenerateRefreshTokenAsync(user);

            session.RefreshToken = refreshToken;
            session.UpdatedAt    = DateTime.Now;
            session.ExpiresAt    = DateTime.Now.AddSeconds(_jwtConfig.RefreshExpirationTime);
            _sessionContext.Update(session);

            if (await _context.SaveChangesAsync() > 0)
            {
                return(new DefaultResponse(accessToken, refreshToken, _jwtConfig.AccessExpirationTime));
            }

            return(null);
        }
 public RefreshLayoutMarginGallery()
 {
     InitializeComponent();
     BindingContext = new RefreshViewModel();
 }