Exemple #1
0
        public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                // maak user aan met formulier data
                var user = new NoviArtUser {
                    UserName = model.Email, Email = model.Email, NoviNumber = model.Number, Type = model.Type, DisplayName = model.DisplayName
                };
                var result = await _userManager.CreateAsync(user, model.Password);

                // controleer resultaat
                if (result.Succeeded)
                {
                    _logger.LogInformation("User created a new account with password.");

                    // verstuur verificatiemail
                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);

                    var callbackUrl = Url.EmailConfirmationLink(user.Id.ToString(), code, Request.Scheme);
                    await _emailSender.SendEmailAsync(model.Email, Localization.EML_CONFIRM_ACCOUNT, Localization.EML_CONFIRM_CLICK + $"<a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>" + Localization.EML_CONFIRM + "</a>");

                    // gebruiker terugsturen naar inlogpagina
                    return(View("EmailNotConfirmed"));
                }
                AddErrors(result);
            }

            // pagina opnieuw laden bij eerdere errors
            return(View(model));
        }
Exemple #2
0
        public async Task <IActionResult> AdminRegister(RegisterViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                // maak gebruiker aan met data uit formulier
                var user = new NoviArtUser {
                    UserName = model.Email, Email = model.Email, NoviNumber = "0", Type = model.Type, DisplayName = model.DisplayName
                };

                // zet account direct bevestigd (apart van de actie hierboven omwille van leesbaarheid)
                user.EmailConfirmed = true;

                // maak account aan
                var result = await _userManager.CreateAsync(user, model.Password);

                // verwerk resultaat
                if (result.Succeeded)
                {
                    _logger.LogInformation("An admin created a new account with password.");
                    return(RedirectToAction("Manage", "Manage"));
                }

                // resultaat niet succesvol,
                AddErrors(result);
            }

            // Toon formulier opnieuw met eerdere errors
            return(View(model));
        }
        public async Task <IActionResult> Manage()
        {
            NoviArtUser user = await _userManager.GetUserAsync(User);

            var wallets = new List <NoviArtWallet>();

            if (user.Type == NoviUserType.Admin || user.Type == NoviUserType.Root)
            {
                // laad alle wallets (voor studenten en medewerkers, admin hebben geen zichtbare wallet)
                foreach (var noviuser in _dbcontext.Users.ToList <NoviArtUser>().Where(u => u.Type == NoviUserType.Medewerker || u.Type == NoviUserType.Student))
                {
                    wallets.Add(new NoviArtWallet {
                        UserID = noviuser.Id, UserName = noviuser.DisplayName, Address = _paymentservice.GetAddress(noviuser.Id), Balance = await _paymentservice.GetBalance(noviuser.Id)
                    });
                }
            }
            else
            {
                wallets.Add(new NoviArtWallet {
                    UserID = user.Id, UserName = user.DisplayName, Address = _paymentservice.GetAddress(user.Id), Balance = await _paymentservice.GetBalance(user.Id)
                });
            }

            return(View(new ManageViewModel {
                User = await _userManager.GetUserAsync(User), DBContext = _dbcontext, Wallets = wallets
            }));
        }
        public async Task <IActionResult> Withdraw(WalletViewModel input)
        {
            // adres controleren
            if (!EthereumPaymentService.IsValidAddress(input.WithdrawAddress))
            {
                return(View("Message", new MessageViewModel {
                    Message = Localization.MSG_ETHADDRESS_NOT_VALID, ReturnToController = "Manage", ReturnToAction = "Manage"
                }));
            }

            // bedrag controleren
            decimal amount;

            try
            {
                amount = Convert.ToDecimal(input.WithdrawAmount);
            }
            catch
            {
                return(View("Message", new MessageViewModel {
                    Message = Localization.MSG_ETHAMOUNT_NOT_VALID, ReturnToController = "Manage", ReturnToAction = "Manage"
                }));
            }

            // user ophalen
            NoviArtUser user = await _userManager.GetUserAsync(User);

            // voer betaling uit
            var result = _paymentservice.SendFunds(user.Id, amount, input.WithdrawAddress).Result;

            // onvoldoende saldo
            if (result == null)
            {
                return(View("Message", new MessageViewModel {
                    Message = Localization.MSG_INSUFFICIENT_ETH, ReturnToController = "Manage", ReturnToAction = "Manage"
                }));
            }

            // betaling gelukt
            if (result.Succeeded())
            {
                return(View("Message", new MessageViewModel {
                    Message = Localization.MSG_PAYMENT_SUCCEEDED, ReturnToController = "Manage", ReturnToAction = "Manage"
                }));
            }

            // betaling mislukt om onbekende reden
            return(View("Message", new MessageViewModel {
                Message = Localization.MSG_PAYMENT_FAILED, ReturnToController = "Manage", ReturnToAction = "Manage"
            }));
        }
        /// <summary>
        /// Methode voor het bevestigen van gebruikersaccounts door een admin, async vanwege database calls
        /// </summary>
        public async Task <IActionResult> ConfirmAccount(string id)
        {
            // zoek de gebruiker
            NoviArtUser user = await _userManager.FindByIdAsync(id);

            if (user != null)
            {
                // zet bevestigd, update database
                user.EmailConfirmed = true;
                await _dbcontext.SaveChangesAsync();

                // logging
                _logger.LogInformation("An admin confirmed an account with id: {0}", id);
            }

            // en herlaadt pagina
            return(RedirectToAction("Manage"));
        }
        /// <summary>
        /// Methode voor het verwijderen van de NoviUser door een admin, async vanwege database calls
        /// </summary>
        public async Task <IActionResult> DeleteUser(string id)
        {
            // zoek de gebruiker
            NoviArtUser user = await _userManager.FindByIdAsync(id);

            if (user != null)
            {
                // controleer of user momenteel niets huurt
                if (await _dbcontext.NoviArtPieces.Where(a => a.Lessee.Id == user.Id).AnyAsync())
                {
                    return(View("Message", new MessageViewModel {
                        Message = Localization.MSG_LESSEE_LOCKED, ReturnToController = "Manage", ReturnToAction = "Manage"
                    }));
                }

                // controleer of user momenteel niets verhuurd
                if (await _dbcontext.NoviArtPieces.Where(a => a.Lesser.Id == user.Id).AnyAsync())
                {
                    return(View("Message", new MessageViewModel {
                        Message = Localization.MSG_LESSER_LOCKED, ReturnToController = "Manage", ReturnToAction = "Manage"
                    }));
                }

                // log gebruiker eerst uit
                await _signInManager.SignOutAsync();

                // verwijder user
                await _userManager.DeleteAsync(user);

                // logging
                _logger.LogInformation("An admin deleted a user with id: {0}", id);
            }


            // en herlaadt pagina
            return(RedirectToAction("Manage"));
        }
        public async Task <IActionResult> DeleteArtPiece(int id)
        {
            // haal artpiece op uit database
            NoviArtPiece entity = await _dbcontext.NoviArtPieces.Include(a => a.Lesser).Where(a => a.Id == id).FirstOrDefaultAsync();

            NoviArtUser user = await _userManager.GetUserAsync(User);

            if (entity != null)
            {
                // controleer of gebruiker het object mag verwijderen
                if (user.Type != NoviUserType.Admin && user.Type != NoviUserType.Root && entity.Lesser.Id != user.Id)
                {
                    return(View("Message", new MessageViewModel {
                        Message = Localization.MSG_UNAUTHORIZED_REMOVAL, ReturnToController = "Manage", ReturnToAction = "Manage"
                    }));
                }

                // controleer of het object momenteel niet verhuurd is
                if (!entity.Available)
                {
                    return(View("Message", new MessageViewModel {
                        Message = Localization.MSG_ARTPIECE_LOCKED, ReturnToController = "Manage", ReturnToAction = "Manage"
                    }));
                }

                // verwijder item uit database
                _dbcontext.NoviArtPieces.Remove(entity);
                await _dbcontext.SaveChangesAsync();

                // logging
                _logger.LogInformation("A user deleted artpiece with id: {0}", id);
            }

            // en herlaadt pagina
            return(RedirectToAction("Manage"));
        }