using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Rendering;
using Microsoft.Extensions.Logging;
using Beerhall.Models.ViewModels.AccountViewModels;
using Beerhall.Services;
using Beerhall.Models.Domain;

namespace Beerhall.Controllers
{
    [Authorize]
    public class AccountController : Controller
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
        private readonly IEmailSender _emailSender;
        private readonly ISmsSender _smsSender;
        private readonly ILogger _logger;
        private readonly ICustomerRepository _customerRepository;
        private readonly ILocationRepository _locationRepository;

        public AccountController(
            UserManager<ApplicationUser> userManager,
            SignInManager<ApplicationUser> signInManager,
            IEmailSender emailSender,
            ISmsSender smsSender,
            ILoggerFactory loggerFactory,
            ICustomerRepository customerRepository,
            ILocationRepository locationRepository)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _emailSender = emailSender;
            _smsSender = smsSender;
            _logger = loggerFactory.CreateLogger<AccountController>();
            _customerRepository = customerRepository;
            _locationRepository = locationRepository;
        }

        //
        // GET: /Account/Login
        [HttpGet]
        [AllowAnonymous]
        public IActionResult Login(string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            return View();
        }

        //
        // POST: /Account/Login
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                // This doesn't count login failures towards account lockout
                // To enable password failures to trigger account lockout, set lockoutOnFailure: true
                var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, lockoutOnFailure: false);
                if (result.Succeeded)
                {
                    _logger.LogInformation(1, "User logged in.");
                    return RedirectToLocal(returnUrl);
                }
                if (result.RequiresTwoFactor)
                {
                    return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl, RememberMe = model.RememberMe });
                }
                if (result.IsLockedOut)
                {
                    _logger.LogWarning(2, "User account locked out.");
                    return View("Lockout");
                }
                else
                {
                    ModelState.AddModelError(string.Empty, "Invalid login attempt.");
                    return View(model);
                }
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        //
        // GET: /Account/Register
        [HttpGet]
        [AllowAnonymous]
        public IActionResult Register(string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            ViewData["Locations"] = new SelectList(
              _locationRepository.GetAll().OrderBy(l => l.Name),
              nameof(Location.PostalCode),
              nameof(Location.Name),
              null);
            return View();
        }

        //
        // POST: /Account/Register
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                var result = await _userManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                    result = await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "customer"));
                if (result.Succeeded) {
                    var customer = new Customer {
                        Email = model.Email,
                        Name = model.Name,
                        FirstName = model.FirstName,
                        Street = model.Street,
                        Location = _locationRepository.GetBy(model.PostalCode)
                    };
                    _customerRepository.Add(customer);
                    _customerRepository.SaveChanges();
                    // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
                    // Send an email with this link
                    //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                    //var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
                    //await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
                    //    $"Please confirm your account by clicking this link: <a href='{callbackUrl}'>link</a>");
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    _logger.LogInformation(3, "User created a new account with password.");
                    return RedirectToLocal(returnUrl);
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        //
        // POST: /Account/LogOff
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> LogOff()
        {
            await _signInManager.SignOutAsync();
            _logger.LogInformation(4, "User logged out.");
            return RedirectToAction(nameof(HomeController.Index), "Home");
        }

        //
        // POST: /Account/ExternalLogin
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public IActionResult ExternalLogin(string provider, string returnUrl = null)
        {
            // Request a redirect to the external login provider.
            var redirectUrl = Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl });
            var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl);
            return Challenge(properties, provider);
        }

        //
        // GET: /Account/ExternalLoginCallback
        [HttpGet]
        [AllowAnonymous]
        public async Task<IActionResult> ExternalLoginCallback(string returnUrl = null, string remoteError = null)
        {
            if (remoteError != null)
            {
                ModelState.AddModelError(string.Empty, $"Error from external provider: {remoteError}");
                return View(nameof(Login));
            }
            var info = await _signInManager.GetExternalLoginInfoAsync();
            if (info == null)
            {
                return RedirectToAction(nameof(Login));
            }

            // Sign in the user with this external login provider if the user already has a login.
            var result = await _signInManager.ExternalLoginSignInAsync(info.LoginProvider, info.ProviderKey, isPersistent: false);
            if (result.Succeeded)
            {
                _logger.LogInformation(5, "User logged in with {Name} provider.", info.LoginProvider);
                return RedirectToLocal(returnUrl);
            }
            if (result.RequiresTwoFactor)
            {
                return RedirectToAction(nameof(SendCode), new { ReturnUrl = returnUrl });
            }
            if (result.IsLockedOut)
            {
                return View("Lockout");
            }
            else
            {
                // If the user does not have an account, then ask the user to create an account.
                ViewData["ReturnUrl"] = returnUrl;
                ViewData["LoginProvider"] = info.LoginProvider;
                var email = info.Principal.FindFirstValue(ClaimTypes.Email);
                return View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = email });
            }
        }

        //
        // POST: /Account/ExternalLoginConfirmation
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl = null)
        {
            if (ModelState.IsValid)
            {
                // Get the information about the user from the external login provider
                var info = await _signInManager.GetExternalLoginInfoAsync();
                if (info == null)
                {
                    return View("ExternalLoginFailure");
                }
                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                var result = await _userManager.CreateAsync(user);
                if (result.Succeeded)
                {
                    result = await _userManager.AddLoginAsync(user, info);
                    if (result.Succeeded)
                    {
                        await _signInManager.SignInAsync(user, isPersistent: false);
                        _logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
                        return RedirectToLocal(returnUrl);
                    }
                }
                AddErrors(result);
            }

            ViewData["ReturnUrl"] = returnUrl;
            return View(model);
        }

        // GET: /Account/ConfirmEmail
        [HttpGet]
        [AllowAnonymous]
        public async Task<IActionResult> ConfirmEmail(string userId, string code)
        {
            if (userId == null || code == null)
            {
                return View("Error");
            }
            var user = await _userManager.FindByIdAsync(userId);
            if (user == null)
            {
                return View("Error");
            }
            var result = await _userManager.ConfirmEmailAsync(user, code);
            return View(result.Succeeded ? "ConfirmEmail" : "Error");
        }

        //
        // GET: /Account/ForgotPassword
        [HttpGet]
        [AllowAnonymous]
        public IActionResult ForgotPassword()
        {
            return View();
        }

        //
        // POST: /Account/ForgotPassword
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> ForgotPassword(ForgotPasswordViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = await _userManager.FindByNameAsync(model.Email);
                if (user == null || !(await _userManager.IsEmailConfirmedAsync(user)))
                {
                    // Don't reveal that the user does not exist or is not confirmed
                    return View("ForgotPasswordConfirmation");
                }

                // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
                // Send an email with this link
                //var code = await _userManager.GeneratePasswordResetTokenAsync(user);
                //var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
                //await _emailSender.SendEmailAsync(model.Email, "Reset Password",
                //   $"Please reset your password by clicking here: <a href='{callbackUrl}'>link</a>");
                //return View("ForgotPasswordConfirmation");
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

        //
        // GET: /Account/ForgotPasswordConfirmation
        [HttpGet]
        [AllowAnonymous]
        public IActionResult ForgotPasswordConfirmation()
        {
            return View();
        }

        //
        // GET: /Account/ResetPassword
        [HttpGet]
        [AllowAnonymous]
        public IActionResult ResetPassword(string code = null)
        {
            return code == null ? View("Error") : View();
        }

        //
        // POST: /Account/ResetPassword
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> ResetPassword(ResetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }
            var user = await _userManager.FindByNameAsync(model.Email);
            if (user == null)
            {
                // Don't reveal that the user does not exist
                return RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account");
            }
            var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password);
            if (result.Succeeded)
            {
                return RedirectToAction(nameof(AccountController.ResetPasswordConfirmation), "Account");
            }
            AddErrors(result);
            return View();
        }

        //
        // GET: /Account/ResetPasswordConfirmation
        [HttpGet]
        [AllowAnonymous]
        public IActionResult ResetPasswordConfirmation()
        {
            return View();
        }

        //
        // GET: /Account/SendCode
        [HttpGet]
        [AllowAnonymous]
        public async Task<ActionResult> SendCode(string returnUrl = null, bool rememberMe = false)
        {
            var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
            if (user == null)
            {
                return View("Error");
            }
            var userFactors = await _userManager.GetValidTwoFactorProvidersAsync(user);
            var factorOptions = userFactors.Select(purpose => new SelectListItem { Text = purpose, Value = purpose }).ToList();
            return View(new SendCodeViewModel { Providers = factorOptions, ReturnUrl = returnUrl, RememberMe = rememberMe });
        }

        //
        // POST: /Account/SendCode
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> SendCode(SendCodeViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View();
            }

            var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
            if (user == null)
            {
                return View("Error");
            }

            // Generate the token and send it
            var code = await _userManager.GenerateTwoFactorTokenAsync(user, model.SelectedProvider);
            if (string.IsNullOrWhiteSpace(code))
            {
                return View("Error");
            }

            var message = "Your security code is: " + code;
            if (model.SelectedProvider == "Email")
            {
                await _emailSender.SendEmailAsync(await _userManager.GetEmailAsync(user), "Security Code", message);
            }
            else if (model.SelectedProvider == "Phone")
            {
                await _smsSender.SendSmsAsync(await _userManager.GetPhoneNumberAsync(user), message);
            }

            return RedirectToAction(nameof(VerifyCode), new { Provider = model.SelectedProvider, ReturnUrl = model.ReturnUrl, RememberMe = model.RememberMe });
        }

        //
        // GET: /Account/VerifyCode
        [HttpGet]
        [AllowAnonymous]
        public async Task<IActionResult> VerifyCode(string provider, bool rememberMe, string returnUrl = null)
        {
            // Require that the user has already logged in via username/password or external login
            var user = await _signInManager.GetTwoFactorAuthenticationUserAsync();
            if (user == null)
            {
                return View("Error");
            }
            return View(new VerifyCodeViewModel { Provider = provider, ReturnUrl = returnUrl, RememberMe = rememberMe });
        }

        //
        // POST: /Account/VerifyCode
        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> VerifyCode(VerifyCodeViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            // The following code protects for brute force attacks against the two factor codes.
            // If a user enters incorrect codes for a specified amount of time then the user account
            // will be locked out for a specified amount of time.
            var result = await _signInManager.TwoFactorSignInAsync(model.Provider, model.Code, model.RememberMe, model.RememberBrowser);
            if (result.Succeeded)
            {
                return RedirectToLocal(model.ReturnUrl);
            }
            if (result.IsLockedOut)
            {
                _logger.LogWarning(7, "User account locked out.");
                return View("Lockout");
            }
            else
            {
                ModelState.AddModelError(string.Empty, "Invalid code.");
                return View(model);
            }
        }

        #region Helpers

        private void AddErrors(IdentityResult result)
        {
            foreach (var error in result.Errors)
            {
                ModelState.AddModelError(string.Empty, error.Description);
            }
        }

        private Task<ApplicationUser> GetCurrentUserAsync()
        {
            return _userManager.GetUserAsync(HttpContext.User);
        }

        private IActionResult RedirectToLocal(string returnUrl)
        {
            if (Url.IsLocalUrl(returnUrl))
            {
                return Redirect(returnUrl);
            }
            else
            {
                return RedirectToAction(nameof(HomeController.Index), "Home");
            }
        }

        #endregion
    }
}



using System;
using System.Collections.Generic;
using Beerhall.Models.Domain;
using Microsoft.AspNetCore.Mvc;
using System.Linq;
using Beerhall.Models.ViewModels.BrewerViewModels;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc.Rendering;

namespace Beerhall.Controllers {
    [Authorize(Policy = "AdminOnly")]
    public class BrewerController : Controller {
        private readonly IBrewerRepository _brewerRepository;
        private readonly ILocationRepository _locationRepository;

        public BrewerController(IBrewerRepository brewerRepository, ILocationRepository locationRepository) {
            _brewerRepository = brewerRepository;
            _locationRepository = locationRepository;
        }

        [AllowAnonymous]
        public IActionResult Index() {
            IEnumerable<Brewer> brewers = _brewerRepository.GetAll().OrderBy(b => b.Name).ToList();
            ViewData["TotalTurnover"] = brewers.Sum(b => b.Turnover);
            return View(brewers);
        }

        public IActionResult Edit(int id) {
            Brewer brewer = _brewerRepository.GetBy(id);
            if (brewer == null)
                return NotFound();
            ViewData["Locations"] = GetLocationsAsSelectList(brewer.Location?.PostalCode);
            return View(new EditViewModel(brewer));
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult Edit(EditViewModel brewerEditViewModel) {
            if (ModelState.IsValid) {
                try {
                    Brewer brewer = _brewerRepository.GetBy(brewerEditViewModel.BrewerId);
                    MapBrewerEditViewModelToBrewer(brewerEditViewModel, brewer);
                    _brewerRepository.SaveChanges();
                    TempData["message"] = $"You successfully updated brewer {brewer.Name}.";
                    return RedirectToAction(nameof(Index));
                }
                catch (Exception e) {
                    ModelState.AddModelError("", e.Message);
                }
            }
            ViewData["Locations"] = GetLocationsAsSelectList(brewerEditViewModel?.PostalCode);
            return View(brewerEditViewModel);
        }

        public IActionResult Create() {
            ViewData["Locations"] = GetLocationsAsSelectList(null);
            return View(nameof(Edit), new EditViewModel(new Brewer()));
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult Create(EditViewModel brewerEditViewModel) {
            if (ModelState.IsValid) {
                try {
                    Brewer brewer = new Brewer();
                    MapBrewerEditViewModelToBrewer(brewerEditViewModel, brewer);
                    _brewerRepository.Add(brewer);
                    _brewerRepository.SaveChanges();
                    TempData["message"] = $"You successfully added brewer {brewer.Name}.";
                    return RedirectToAction(nameof(Index));
                }
                catch (Exception e) {
                    ModelState.AddModelError("", e.Message);
                }
            }
            ViewData["Locations"] = GetLocationsAsSelectList(brewerEditViewModel?.PostalCode);
            return View(nameof(Edit), brewerEditViewModel);
        }

        public IActionResult Delete(int id) {
            Brewer brewer = _brewerRepository.GetBy(id);
            if (brewer == null)
                return NotFound();
            ViewData[nameof(Brewer.Name)] = brewer.Name;
            return View();
        }

        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public IActionResult DeleteConfirmed(int id) {
            Brewer brewer = null;
            try {
                brewer = _brewerRepository.GetBy(id);
                _brewerRepository.Delete(brewer);
                _brewerRepository.SaveChanges();
                TempData["message"] = $"You successfully deleted brewer {brewer.Name}.";
            }
            catch {
                TempData["error"] = $"Sorry, something went wrong, brewer {brewer?.Name} was not deleted...";
            }
            return RedirectToAction(nameof(Index));
        }

        private SelectList GetLocationsAsSelectList(string postalCode) {
            return new SelectList(
                _locationRepository.GetAll().OrderBy(l => l.Name),
                nameof(Location.PostalCode),
                nameof(Location.Name),
                postalCode);
        }

        private void MapBrewerEditViewModelToBrewer(EditViewModel brewerEditViewModel, Brewer brewer) {
            brewer.Name = brewerEditViewModel.Name;
            brewer.Street = brewerEditViewModel.Street;
            brewer.Location = brewerEditViewModel.PostalCode == null
                ? null
                : _locationRepository.GetBy(brewerEditViewModel.PostalCode);
            brewer.ContactEmail = brewerEditViewModel.ContactEmail;
            brewer.DateEstablished = brewerEditViewModel.DateEstablished;
            brewer.Description = brewerEditViewModel.Description;
            brewer.Turnover = brewerEditViewModel.Turnover;
        }
    }
}



using System;
using System.Collections.Generic;
using System.Linq;
using Beerhall.Filters;
using Microsoft.AspNetCore.Mvc;
using Beerhall.Models.Domain;
using Beerhall.Models.ViewModels.CartViewModels;
using Microsoft.AspNetCore.Authorization;

namespace Beerhall.Controllers {
    [ServiceFilter(typeof(CartSessionFilter))]
    public class CartController : Controller {
        private readonly IBeerRepository _beerRepository;
        private readonly ILocationRepository _locationRepository;
        private readonly ICustomerRepository _customerRepository;

        public CartController(IBeerRepository beerRepository, ILocationRepository locationRepository, ICustomerRepository customerRepository) {
            _beerRepository = beerRepository;
            _locationRepository = locationRepository;
            _customerRepository = customerRepository;
        }

        public IActionResult Index(Cart cart) {
            ViewData["Total"] = cart.TotalValue;
            return View(cart.CartLines.Select(c => new IndexViewModel(c)).ToList());
        }

        [HttpPost]
        public IActionResult Add(Cart cart, int id, int quantity = 1) {
            try {
                Beer product = _beerRepository.GetBy(id);
                if (product != null) {
                    cart.AddLine(product, quantity);
                    TempData["message"] = $"{quantity} x {product.Name} was added to your shopping basket";
                }
            }
            catch {
                TempData["error"] = "Sorry, something went wrong, the product could not be added to your shopping cart...";
            }
            return RedirectToAction("Index", "Store");
        }

        [HttpPost]
        public IActionResult Remove(Cart cart, int id) {
            try {
                Beer product = _beerRepository.GetBy(id);
                cart.RemoveLine(product);
                TempData["message"] = $"{product.Name} was removed from you shopping basket";
            }
            catch {
                TempData["error"] = "Sorry, something went wrong, the product was not removed from your shopping cart...";
            }
            return RedirectToAction("Index");
        }

        [Authorize(Policy = "Customer")]
        public IActionResult Checkout(Cart cart) {
            if (cart.NumberOfItems == 0)
                return RedirectToAction("Index", "Store");
            IEnumerable<Location> locations = _locationRepository.GetAll().OrderBy(l => l.Name).ToList();
            return View(new CheckOutViewModel(locations, new ShippingViewModel()));
        }

        [HttpPost, Authorize(Policy = "Customer")]
        [ServiceFilter(typeof(CustomerFilter))]
        public IActionResult Checkout(Customer customer, Cart cart, [Bind(Prefix = "ShippingViewModel")]ShippingViewModel shippingVm) {
            if (ModelState.IsValid) {
                try {
                    if (cart.NumberOfItems == 0)
                        return RedirectToAction("Index");
                    Location location = _locationRepository.GetBy(shippingVm.PostalCode);
                    customer.PlaceOrder(cart, shippingVm.DeliveryDate, shippingVm.Giftwrapping, shippingVm.Street, location);
                    _customerRepository.SaveChanges();
                    cart.Clear();
                    TempData["message"] = "Thank you for your order!";
                    return RedirectToAction("Index", "Store");
                }
                catch (Exception ex) {
                    ModelState.AddModelError("", ex.Message);
                }
            }
            IEnumerable<Location> locations = _locationRepository.GetAll().OrderBy(l => l.Name);
            return View(new CheckOutViewModel(locations, shippingVm));
        }
    }
}


using Microsoft.AspNetCore.Mvc;

namespace Beerhall.Controllers
{
    public class HomeController : Controller
    {
        public IActionResult Index()
        {
            return View();
        }

        public IActionResult About()
        {
            ViewData["Message"] = "Your application description page.";

            return View();
        }

        public IActionResult Contact()
        {
            ViewData["Message"] = "Your contact page.";

            return View();
        }

        public IActionResult Error()
        {
            return View();
        }
    }
}



using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Beerhall.Models.ViewModels.ManageViewModels;
using Beerhall.Services;
using Beerhall.Models.Domain;

namespace Beerhall.Controllers
{
    [Authorize]
    public class ManageController : Controller
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
        private readonly IEmailSender _emailSender;
        private readonly ISmsSender _smsSender;
        private readonly ILogger _logger;

        public ManageController(
        UserManager<ApplicationUser> userManager,
        SignInManager<ApplicationUser> signInManager,
        IEmailSender emailSender,
        ISmsSender smsSender,
        ILoggerFactory loggerFactory)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _emailSender = emailSender;
            _smsSender = smsSender;
            _logger = loggerFactory.CreateLogger<ManageController>();
        }

        //
        // GET: /Manage/Index
        [HttpGet]
        public async Task<IActionResult> Index(ManageMessageId? message = null)
        {
            ViewData["StatusMessage"] =
                message == ManageMessageId.ChangePasswordSuccess ? "Your password has been changed."
                : message == ManageMessageId.SetPasswordSuccess ? "Your password has been set."
                : message == ManageMessageId.SetTwoFactorSuccess ? "Your two-factor authentication provider has been set."
                : message == ManageMessageId.Error ? "An error has occurred."
                : message == ManageMessageId.AddPhoneSuccess ? "Your phone number was added."
                : message == ManageMessageId.RemovePhoneSuccess ? "Your phone number was removed."
                : "";

            var user = await GetCurrentUserAsync();
            if (user == null)
            {
                return View("Error");
            }
            var model = new IndexViewModel
            {
                HasPassword = await _userManager.HasPasswordAsync(user),
                PhoneNumber = await _userManager.GetPhoneNumberAsync(user),
                TwoFactor = await _userManager.GetTwoFactorEnabledAsync(user),
                Logins = await _userManager.GetLoginsAsync(user),
                BrowserRemembered = await _signInManager.IsTwoFactorClientRememberedAsync(user)
            };
            return View(model);
        }

        //
        // POST: /Manage/RemoveLogin
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> RemoveLogin(RemoveLoginViewModel account)
        {
            ManageMessageId? message = ManageMessageId.Error;
            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                var result = await _userManager.RemoveLoginAsync(user, account.LoginProvider, account.ProviderKey);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    message = ManageMessageId.RemoveLoginSuccess;
                }
            }
            return RedirectToAction(nameof(ManageLogins), new { Message = message });
        }

        //
        // GET: /Manage/AddPhoneNumber
        public IActionResult AddPhoneNumber()
        {
            return View();
        }

        //
        // POST: /Manage/AddPhoneNumber
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> AddPhoneNumber(AddPhoneNumberViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }
            // Generate the token and send it
            var user = await GetCurrentUserAsync();
            if (user == null)
            {
                return View("Error");
            }
            var code = await _userManager.GenerateChangePhoneNumberTokenAsync(user, model.PhoneNumber);
            await _smsSender.SendSmsAsync(model.PhoneNumber, "Your security code is: " + code);
            return RedirectToAction(nameof(VerifyPhoneNumber), new { PhoneNumber = model.PhoneNumber });
        }

        //
        // POST: /Manage/EnableTwoFactorAuthentication
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> EnableTwoFactorAuthentication()
        {
            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                await _userManager.SetTwoFactorEnabledAsync(user, true);
                await _signInManager.SignInAsync(user, isPersistent: false);
                _logger.LogInformation(1, "User enabled two-factor authentication.");
            }
            return RedirectToAction(nameof(Index), "Manage");
        }

        //
        // POST: /Manage/DisableTwoFactorAuthentication
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> DisableTwoFactorAuthentication()
        {
            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                await _userManager.SetTwoFactorEnabledAsync(user, false);
                await _signInManager.SignInAsync(user, isPersistent: false);
                _logger.LogInformation(2, "User disabled two-factor authentication.");
            }
            return RedirectToAction(nameof(Index), "Manage");
        }

        //
        // GET: /Manage/VerifyPhoneNumber
        [HttpGet]
        public async Task<IActionResult> VerifyPhoneNumber(string phoneNumber)
        {
            var user = await GetCurrentUserAsync();
            if (user == null)
            {
                return View("Error");
            }
            var code = await _userManager.GenerateChangePhoneNumberTokenAsync(user, phoneNumber);
            // Send an SMS to verify the phone number
            return phoneNumber == null ? View("Error") : View(new VerifyPhoneNumberViewModel { PhoneNumber = phoneNumber });
        }

        //
        // POST: /Manage/VerifyPhoneNumber
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> VerifyPhoneNumber(VerifyPhoneNumberViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }
            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                var result = await _userManager.ChangePhoneNumberAsync(user, model.PhoneNumber, model.Code);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    return RedirectToAction(nameof(Index), new { Message = ManageMessageId.AddPhoneSuccess });
                }
            }
            // If we got this far, something failed, redisplay the form
            ModelState.AddModelError(string.Empty, "Failed to verify phone number");
            return View(model);
        }

        //
        // POST: /Manage/RemovePhoneNumber
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> RemovePhoneNumber()
        {
            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                var result = await _userManager.SetPhoneNumberAsync(user, null);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    return RedirectToAction(nameof(Index), new { Message = ManageMessageId.RemovePhoneSuccess });
                }
            }
            return RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error });
        }

        //
        // GET: /Manage/ChangePassword
        [HttpGet]
        public IActionResult ChangePassword()
        {
            return View();
        }

        //
        // POST: /Manage/ChangePassword
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> ChangePassword(ChangePasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }
            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                var result = await _userManager.ChangePasswordAsync(user, model.OldPassword, model.NewPassword);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    _logger.LogInformation(3, "User changed their password successfully.");
                    return RedirectToAction(nameof(Index), new { Message = ManageMessageId.ChangePasswordSuccess });
                }
                AddErrors(result);
                return View(model);
            }
            return RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error });
        }

        //
        // GET: /Manage/SetPassword
        [HttpGet]
        public IActionResult SetPassword()
        {
            return View();
        }

        //
        // POST: /Manage/SetPassword
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> SetPassword(SetPasswordViewModel model)
        {
            if (!ModelState.IsValid)
            {
                return View(model);
            }

            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                var result = await _userManager.AddPasswordAsync(user, model.NewPassword);
                if (result.Succeeded)
                {
                    await _signInManager.SignInAsync(user, isPersistent: false);
                    return RedirectToAction(nameof(Index), new { Message = ManageMessageId.SetPasswordSuccess });
                }
                AddErrors(result);
                return View(model);
            }
            return RedirectToAction(nameof(Index), new { Message = ManageMessageId.Error });
        }

        //GET: /Manage/ManageLogins
        [HttpGet]
        public async Task<IActionResult> ManageLogins(ManageMessageId? message = null)
        {
            ViewData["StatusMessage"] =
                message == ManageMessageId.RemoveLoginSuccess ? "The external login was removed."
                : message == ManageMessageId.AddLoginSuccess ? "The external login was added."
                : message == ManageMessageId.Error ? "An error has occurred."
                : "";
            var user = await GetCurrentUserAsync();
            if (user == null)
            {
                return View("Error");
            }
            var userLogins = await _userManager.GetLoginsAsync(user);
            var otherLogins = _signInManager.GetExternalAuthenticationSchemes().Where(auth => userLogins.All(ul => auth.AuthenticationScheme != ul.LoginProvider)).ToList();
            ViewData["ShowRemoveButton"] = user.PasswordHash != null || userLogins.Count > 1;
            return View(new ManageLoginsViewModel
            {
                CurrentLogins = userLogins,
                OtherLogins = otherLogins
            });
        }

        //
        // POST: /Manage/LinkLogin
        [HttpPost]
        [ValidateAntiForgeryToken]
        public IActionResult LinkLogin(string provider)
        {
            // Request a redirect to the external login provider to link a login for the current user
            var redirectUrl = Url.Action("LinkLoginCallback", "Manage");
            var properties = _signInManager.ConfigureExternalAuthenticationProperties(provider, redirectUrl, _userManager.GetUserId(User));
            return Challenge(properties, provider);
        }

        //
        // GET: /Manage/LinkLoginCallback
        [HttpGet]
        public async Task<ActionResult> LinkLoginCallback()
        {
            var user = await GetCurrentUserAsync();
            if (user == null)
            {
                return View("Error");
            }
            var info = await _signInManager.GetExternalLoginInfoAsync(await _userManager.GetUserIdAsync(user));
            if (info == null)
            {
                return RedirectToAction(nameof(ManageLogins), new { Message = ManageMessageId.Error });
            }
            var result = await _userManager.AddLoginAsync(user, info);
            var message = result.Succeeded ? ManageMessageId.AddLoginSuccess : ManageMessageId.Error;
            return RedirectToAction(nameof(ManageLogins), new { Message = message });
        }

        #region Helpers

        private void AddErrors(IdentityResult result)
        {
            foreach (var error in result.Errors)
            {
                ModelState.AddModelError(string.Empty, error.Description);
            }
        }

        public enum ManageMessageId
        {
            AddPhoneSuccess,
            AddLoginSuccess,
            ChangePasswordSuccess,
            SetTwoFactorSuccess,
            SetPasswordSuccess,
            RemoveLoginSuccess,
            RemovePhoneSuccess,
            Error
        }

        private Task<ApplicationUser> GetCurrentUserAsync()
        {
            return _userManager.GetUserAsync(HttpContext.User);
        }

        #endregion
    }
}



using System.Linq;
using Beerhall.Models.Domain;
using Microsoft.AspNetCore.Mvc;

namespace Beerhall.Controllers {
    public class StoreController : Controller {
        private readonly IBeerRepository _beerRepository;

        public StoreController(IBeerRepository beerRepository) {
            _beerRepository = beerRepository;
        }
        [ResponseCache(Duration = 60)]
        public ActionResult Index() {
            return View(_beerRepository.GetAll().OrderBy(b => b.Name).ToList());
        }
    }
}


using System.Collections.Generic;
using System.Linq;
using Beerhall.Models.Domain;
using Microsoft.EntityFrameworkCore;

namespace Beerhall.Data.Repositories {
    public class BeerRepository : IBeerRepository {
        private readonly ApplicationDbContext _dbContext;
        private readonly DbSet<Beer> _beers;

        public BeerRepository(ApplicationDbContext dbContext) {
            _dbContext = dbContext;
            _beers = _dbContext.Beers;
        }

        public IEnumerable<Beer> GetAll() {
            return _beers.ToList();
        }
        public Beer GetBy(int beerId) {
            return _beers.SingleOrDefault(b => b.BeerId == beerId);
        }
    }
}



using System.Collections.Generic;
using System.Linq;
using Beerhall.Models.Domain;
using Microsoft.EntityFrameworkCore;

namespace Beerhall.Data.Repositories {

    public class BrewerRepository : IBrewerRepository {
        private readonly ApplicationDbContext _dbContext;
        private readonly DbSet<Brewer> _brewers;

        public BrewerRepository(ApplicationDbContext dbContext) {
            _dbContext = dbContext;
            _brewers = dbContext.Brewers;
        }

        public Brewer GetBy(int brewerId) {
            return _brewers.Include(b => b.Location).SingleOrDefault(b => b.BrewerId == brewerId);
        }

        public IEnumerable<Brewer> GetAll() {
            return _brewers.Include(b => b.Location).Include(b => b.Beers).ToList();
        }

        public void Add(Brewer brewer) {
            _brewers.Add(brewer);
        }

        public void Delete(Brewer brewer) {
            _brewers.Remove(brewer);
        }

        public void SaveChanges() {
            _dbContext.SaveChanges();
        }
    }
}



using System.Linq;
using Beerhall.Models.Domain;
using Microsoft.EntityFrameworkCore;

namespace Beerhall.Data.Repositories {
    public class CustomerRepository : ICustomerRepository {
        private DbSet<Customer> _customers;
        private ApplicationDbContext _dbContext;

        public CustomerRepository(ApplicationDbContext dbContext) {
            _dbContext = dbContext;
            _customers = _dbContext.Customers;

        }
        public Customer GetBy(string email) {
            return _customers.Include(c => c.Location).SingleOrDefault(c => c.Email == email);
        }
        public void Add(Customer customer) {
            _customers.Add(customer);
        }

        public void SaveChanges() {
            _dbContext.SaveChanges();
        }
    }
}



using System.Collections.Generic;
using System.Linq;
using Beerhall.Models.Domain;
using Microsoft.EntityFrameworkCore;

namespace Beerhall.Data.Repositories {
    public class LocationRepository : ILocationRepository {
        private readonly DbSet<Location> _locations;

        public LocationRepository(ApplicationDbContext dbContext) {
            _locations = dbContext.Locations;
        }
        public Location GetBy(string postalCode) {
            return _locations.SingleOrDefault(l => l.PostalCode == postalCode);
        }

        public IEnumerable<Location> GetAll() {
            return _locations.ToList();
        }
    }
}




using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore;
using Beerhall.Models.Domain;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace Beerhall.Data {
    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext(DbContextOptions<ApplicationDbContext> options)
            : base(options)
        {
        }

        public DbSet<Brewer> Brewers { get; set; }
        public DbSet<Beer> Beers { get; set; }
        public DbSet<Location> Locations { get; set; }
        public DbSet<Customer> Customers { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder) {
            base.OnModelCreating(modelBuilder);
            modelBuilder.Entity<Brewer>(MapBrewer);
            modelBuilder.Entity<Beer>(MapBeer);
            modelBuilder.Entity<Location>(MapLocation);
            modelBuilder.Entity<Order>(MapOrder);
            modelBuilder.Entity<OrderLine>(MapOrderLine);
        }

        public static void MapOrder(EntityTypeBuilder<Order> o) {
            o.ToTable("Order");
            o.Property(t => t.Street).IsRequired().HasMaxLength(100);
            o.HasMany(t => t.OrderLines).WithOne().HasForeignKey(t => t.OrderId).IsRequired().OnDelete(DeleteBehavior.Cascade);
            o.HasOne(c => c.Location).WithMany().IsRequired().OnDelete(DeleteBehavior.Restrict);
        }

        public static void MapOrderLine(EntityTypeBuilder<OrderLine> ol) {
            ol.ToTable("OrderLine");
            ol.HasKey(t => new {
                t.OrderId,
                t.ProductId
            });
            ol.HasOne(o => o.Product).WithMany().IsRequired().HasForeignKey(o => o.ProductId).OnDelete(DeleteBehavior.Restrict);
        }

        private static void MapLocation(EntityTypeBuilder<Location> l) {
            //Table name
            l.ToTable("Location");

            //Primary Key
            l.HasKey(t => t.PostalCode);

            //Properties
            l.Property(t => t.Name)
                .IsRequired()
                .HasMaxLength(50);
        }


        private void MapBeer(EntityTypeBuilder<Beer> b) {
            //Table name
            b.ToTable("Beer");
            // Properties
            b.Property(t => t.Name).IsRequired().HasMaxLength(100);
        }

        private static void MapBrewer(EntityTypeBuilder<Brewer> b) {
            //Table name
            b.ToTable("Brewer");

            //Primary Key
            b.HasKey(t => t.BrewerId);

            //Properties
            b.Property(t => t.Name)
                .HasColumnName("BrewerName")
                .IsRequired()
                .HasMaxLength(100);

            b.Property(t => t.ContactEmail)
                .HasMaxLength(100);

            b.Property(t => t.Street)
                .HasMaxLength(100);

            b.Property(t => t.BrewerId)
                .ValueGeneratedOnAdd();

            //Associations
            b.HasMany(t => t.Beers)
                .WithOne()
                .IsRequired()
                .OnDelete(DeleteBehavior.Cascade);

            b.HasOne(t => t.Location)
               .WithMany()
               .IsRequired(false)
               .OnDelete(DeleteBehavior.Restrict);
        }
    }
}



using System;
using System.Security.Claims;
using System.Threading.Tasks;
using Beerhall.Models.Domain;
using Microsoft.AspNetCore.Identity;
using System.Linq;

namespace Beerhall.Data {
    public class BeerhallDataInitializer {
        private readonly ApplicationDbContext _dbContext;
        private readonly UserManager<ApplicationUser> _userManager;

        public BeerhallDataInitializer(ApplicationDbContext dbContext, UserManager<ApplicationUser> userManager) {
            _dbContext = dbContext;
            _userManager = userManager;
        }

        public async Task InitializeData() {
            _dbContext.Database.EnsureDeleted();
            if (_dbContext.Database.EnsureCreated()) {
                Location bavikhove = new Location { Name = "Bavikhove", PostalCode = "8531" };
                Location roeselare = new Location { Name = "Roeselare", PostalCode = "8800" };
                Location puurs = new Location { Name = "Puurs", PostalCode = "2870" };
                Location leuven = new Location { Name = "Leuven", PostalCode = "3000" };
                Location oudenaarde = new Location { Name = "Oudenaarde", PostalCode = "9700" };
                Location affligem = new Location { Name = "Affligem", PostalCode = "1790" };
                Location[] locations = { bavikhove, roeselare, puurs, leuven, oudenaarde, affligem };
                _dbContext.Locations.AddRange(locations);
                _dbContext.SaveChanges();

                Brewer bavik = new Brewer("Bavik", bavikhove, "Rijksweg 33");
                _dbContext.Brewers.Add(bavik);
                bavik.AddBeer("Bavik Pils", 5.2, 0.80M,
                    "De Bavik Premium Pils wordt gebrouwen met de beste mout en hop en verdient koel geschonken te worden.");
                bavik.AddBeer("Wittekerke", 5.0, 0.90M, "Wittekerke 1/4");
                bavik.AddBeer("Wittekerke Speciale", 5.8, 2.35M);
                bavik.AddBeer("Wittekerke Rosé", 4.3, 1.79M);
                bavik.AddBeer("Ezel Wit", 5.8, 1.79M);
                bavik.AddBeer("Ezel Bruin", 6.5, 1.69M);
                bavik.Turnover = 20000000;
                bavik.DateEstablished = new DateTime(1990, 12, 26);
                bavik.ContactEmail = "info@bavik.be";
                bavik.Description =
                    "Brouwerij De Brabandere kan terugblikken op een rijke geschiedenis, maar kijkt met evenveel vertrouwen naar de toekomst. De droom die stichter Adolphe De Brabandere op het eind van de negentiende eeuw koestert wanneer hij in Bavikhove de fundamenten legt van zijn brouwerij, is realiteit geworden in de succesvolle onderneming van vandaag.Met een rijk assortiment bieren dat gesmaakt wordt door kenners tot ver buiten onze landsgrenzen.Brouwen was, is, en blijft een kunst bij Brouwerij De Brabandere. Beschouw onze talrijke karaktervolle bieren gerust als erfgoed: gemaakt met traditioneel vakmanschap, met authentieke ingrediënten en… veel liefde. Het creëren van een unieke smaaksensatie om te delen met vrienden, dat drijft ons dag in dag uit.  Zonder compromissen.";

                Brewer palm = new Brewer("Palm Breweries");
                _dbContext.Brewers.Add(palm);
                palm.AddBeer("Estimanet", 5.2, 1.39M);
                palm.AddBeer("Steenbrugge Blond", 6.5, 1.80M);
                palm.AddBeer("Palm", 5.4, 0.90M);
                palm.AddBeer("Dobbel Palm", 6.0, 1.15M);
                palm.Turnover = 500000;

                Brewer duvelMoortgat = new Brewer("Duvel Moortgat", puurs, "Breendonkdorp 28");
                _dbContext.Brewers.Add(duvelMoortgat);
                duvelMoortgat.AddBeer("Duvel", 8.5, 1.78M);
                duvelMoortgat.AddBeer("Vedett", price: 1.79M);
                duvelMoortgat.AddBeer("Maredsous", price: 1.69M);
                duvelMoortgat.AddBeer("Liefmans Kriekbier", price: 2.35M);
                duvelMoortgat.AddBeer("La Chouffe", 8.0, 1.69M);
                duvelMoortgat.AddBeer("De Koninck", 5.0, 0.79M);

                Brewer inBev = new Brewer("InBev", leuven, "Brouwerijplein 1");
                _dbContext.Brewers.Add(inBev);
                inBev.AddBeer("Jupiler", price: 1.19M);
                inBev.AddBeer("Stella Artois", price: 1.19M);
                inBev.AddBeer("Leffe", price: 1.89M);
                inBev.AddBeer("Belle-Vue", price: 1.25M);
                inBev.AddBeer("Hoegaarden", price: 0.89M);

                Brewer roman = new Brewer("Roman", oudenaarde, "Hauwaart 105");
                _dbContext.Brewers.Add(roman);
                roman.AddBeer("Sloeber", 7.5, 1.20M);
                roman.AddBeer("Black Hole", 5.6, 1.68M);
                roman.AddBeer("Ename", 6.5, 2.19M);
                roman.AddBeer("Romy Pils", 5.1, 0.65M);

                Brewer deGraal = new Brewer("De Graal");
                _dbContext.Brewers.Add(deGraal);

                Brewer deLeeuw = new Brewer("De Leeuw");
                _dbContext.Brewers.Add(deLeeuw);

                _dbContext.SaveChanges();

                await InitializeUsersAndCustomers();

            }
        }

        private async Task InitializeUsersAndCustomers() {
            string eMailAddress = "beermaster@hogent.be";
            ApplicationUser user = new ApplicationUser { UserName = eMailAddress, Email = eMailAddress };
            await _userManager.CreateAsync(user, "P@ssword1");
            await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "admin"));

            eMailAddress = "jan@hogent.be";
            user = new ApplicationUser { UserName = eMailAddress, Email = eMailAddress };
            await _userManager.CreateAsync(user, "P@ssword1");
            await _userManager.AddClaimAsync(user, new Claim(ClaimTypes.Role, "customer"));

            var customer = new Customer {
                Email = eMailAddress,
                FirstName = "Jan",
                Name = "De man",
                Location = _dbContext.Locations.SingleOrDefault(l => l.PostalCode == "9700"),
                Street = "Nederstraat 5"
            };

            _dbContext.Customers.Add(customer);
            _dbContext.SaveChanges();
        }
    }
}




using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc.Filters;
using Newtonsoft.Json;
using Beerhall.Models.Domain;

namespace Beerhall.Filters {

    public class CartSessionFilter : ActionFilterAttribute {
        private readonly IBeerRepository _beerRepository;
        private Cart _cart;

        public CartSessionFilter(IBeerRepository beerRepository) {
            _beerRepository = beerRepository;
        }

        public override void OnActionExecuting(ActionExecutingContext context) {
            _cart = ReadCartFromSession(context.HttpContext);
            context.ActionArguments["cart"] = _cart;
            base.OnActionExecuting(context);
        }

        public override void OnActionExecuted(ActionExecutedContext context) {
            WriteCartToSession(_cart, context.HttpContext);
            base.OnActionExecuted(context);
        }

        private Cart ReadCartFromSession(HttpContext context) {
            Cart cart = context.Session.GetString("cart") == null ?
                new Cart() : JsonConvert.DeserializeObject<Cart>(context.Session.GetString("cart"));
            foreach (var l in cart.CartLines)
                l.Product = _beerRepository.GetBy(l.Product.BeerId);
            return cart;
        }

        private void WriteCartToSession(Cart cart, HttpContext context) {
            context.Session.SetString("cart", JsonConvert.SerializeObject(cart));
        }
    }
}




using Beerhall.Models.Domain;
using Microsoft.AspNetCore.Mvc.Filters;

namespace Beerhall.Filters {
    public class CustomerFilter : ActionFilterAttribute {
        private readonly ICustomerRepository _customerRepository;

        public CustomerFilter(ICustomerRepository customerRespoitory) {
            _customerRepository = customerRespoitory;
        }

        public override void OnActionExecuting(ActionExecutingContext context) {
            context.ActionArguments["customer"] = context.HttpContext.User.Identity.IsAuthenticated ? _customerRepository.GetBy(context.HttpContext.User.Identity.Name) : null;
            base.OnActionExecuting(context);
        }
    }
}



using Microsoft.AspNetCore.Identity.EntityFrameworkCore;

namespace Beerhall.Models.Domain {
    public class ApplicationUser : IdentityUser {

    }
}



using System;
using Newtonsoft.Json;

namespace Beerhall.Models.Domain {
    [JsonObject(MemberSerialization.OptIn)]
    public class Beer {
        #region Fields
        private string _name;
        #endregion

        #region Properties
        [JsonProperty]
        public int BeerId { get; set; }
        public string Name {
            get {
                return _name;
            }
            private set {
                if (string.IsNullOrWhiteSpace(value))
                    throw new ArgumentException("A beer must be given a name");
                _name = value;
            }
        }
        public string Description { get; set; }
        public double? AlcoholByVolume { get; set; }
        public bool AlcoholKnown => AlcoholByVolume.HasValue;
        public decimal Price { get; set; }
        #endregion

        #region Constructors
        [JsonConstructor]
        protected Beer() {

        }

        public Beer(string name) : this() {
            Name = name;
        }
        #endregion
    }
}


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Beerhall.Models.Domain {
    public class Brewer {
        #region Fields
        private string _name;
        private string _contactEmail;
        private int? _turnover;
        private DateTime? _dateEstablished;
        #endregion

        #region Properties
        public int BrewerId {
            get; set;
        }
        public string Name {
            get {
                return _name;
            }
            set {
                if (string.IsNullOrWhiteSpace(value))
                    throw new ArgumentException("A brewer must have a name");
                if (value.Length > 50)
                    throw new ArgumentException("Name of brewer must not exceed 50 characters");
                _name = value;
            }
        }
        public string Description {
            get; set;
        }

        public string ContactEmail {
            get { return _contactEmail; }
            set {
                if (value != null) {
                    Regex regex = new Regex(@"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}");
                    Match match = regex.Match(value);
                    if (!match.Success)
                        throw new ArgumentException("Email address is not valid");
                    _contactEmail = value;
                }
            }
        }
        public DateTime? DateEstablished {
            get { return _dateEstablished; }
            set {
                if (value > DateTime.Today)
                    throw new ArgumentException("Date established must be in the past");
                _dateEstablished = value;

            }
        }
        public string Street {
            get; set;
        }
        public Location Location {
            get; set;
        }
        public int? Turnover {
            get {
                return _turnover;
            }
            set {
                if (value.GetValueOrDefault() < 0)
                    throw new ArgumentException("Turnover must be positive");
                _turnover = value;
            }
        }

        public ICollection<Beer> Beers {
            get;
        }

        public int NrOfBeers => Beers.Count;

        #endregion

        #region Constructors
        public Brewer() {
            Beers = new HashSet<Beer>();
            _turnover = null;
        }

        public Brewer(string name) : this() {
            Name = name;
        }

        public Brewer(string name, Location location, string street)
            : this(name) {
            Location = location;
            Street = street;
        }
        #endregion

        #region Methods
        public Beer AddBeer(string name, double? alcoholByVolume = null, decimal price = 0, string description = null) {
            if (name != null && Beers.FirstOrDefault(b => b.Name == name) != null)
                throw new ArgumentException($"Brewer {Name} has already a beer by the name of {name}");
            Beer newBeer = new Beer(name) {
                AlcoholByVolume = alcoholByVolume,
                Description = description,
                Price = price
            };
            Beers.Add(newBeer);
            return newBeer;
        }

        public void DeleteBeer(Beer beer) {
            if (!Beers.Contains(beer))
                throw new ArgumentException($"{beer.Name} is not a {Name} beer");
            Beers.Remove(beer);
        }

        public Beer GetBy(int beerId) {
            return Beers.FirstOrDefault(b => b.BeerId == beerId);
        }

        public Beer GetBy(string name) {
            return Beers.FirstOrDefault(b => b.Name == name);
        }
        #endregion
    }
}


using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json;

namespace Beerhall.Models.Domain {
    [JsonObject(MemberSerialization.OptIn)]
    public class Cart {
        #region Properties
        [JsonProperty]
        private readonly IList<CartLine> _lines = new List<CartLine>();
        public IEnumerable<CartLine> CartLines => _lines.AsEnumerable();
        public int NumberOfItems => _lines.Count;
        public decimal TotalValue {
            get { return _lines.Sum(l => l.Product.Price * l.Quantity); }
        }
        #endregion

        #region Methods
        public void AddLine(Beer product, int quantity) {
            CartLine line = _lines.SingleOrDefault(l => l.Product.BeerId == product.BeerId);
            if (line == null)
                _lines.Add(new CartLine { Product = product, Quantity = quantity });
            else
                line.Quantity += quantity;
        }

        public void RemoveLine(Beer product) {
            CartLine line = _lines.SingleOrDefault(l => l.Product.BeerId == product.BeerId);
            if (line != null)
                _lines.Remove(line);
        }

        public void Clear() {
            _lines.Clear();
        }
        #endregion
    }
}


using Newtonsoft.Json;

namespace Beerhall.Models.Domain {
    [JsonObject(MemberSerialization.OptIn)]
    public class CartLine {
        [JsonProperty]
        public int Quantity { get; set; }
        [JsonProperty]
        public Beer Product { get; set; }
        public decimal Total => Product.Price * Quantity;
    }
}


using System;
using System.Collections.Generic;

namespace Beerhall.Models.Domain {
    public class Customer {
        #region Properties
        public int CustomerId { get; set; }
        public string Email { get; set; }
        public string Name { get; set; }
        public string FirstName { get; set; }
        public string Street { get; set; }
        public Location Location { get; set; }
        public ICollection<Order> Orders { get; set; }
        #endregion

        #region Methods
        public Customer() {
            Orders = new List<Order>();
        }

        public void PlaceOrder(Cart cart, DateTime? deliveryDate, bool giftwrapping, string shippingStreet, Location shippingCity) {
            Orders.Add(new Order(cart, deliveryDate, giftwrapping, shippingStreet, shippingCity));
        }
        #endregion
    }
}



using System.Collections.Generic;

namespace Beerhall.Models.Domain {
    public interface IBeerRepository {
        IEnumerable<Beer> GetAll();
        Beer GetBy(int beerId);
    }
}


using System.Collections.Generic;

namespace Beerhall.Models.Domain {
    public interface IBrewerRepository {
        Brewer GetBy(int brewerId);
        IEnumerable<Brewer> GetAll();
        void Add(Brewer brewer);
        void Delete(Brewer brewer);
        void SaveChanges();
    }
}




namespace Beerhall.Models.Domain {
    public interface ICustomerRepository {
        Customer GetBy(string email);
        void Add(Customer customer);
        void SaveChanges();
    }
}



using System.Collections.Generic;

namespace Beerhall.Models.Domain {
    public interface ILocationRepository {
        Location GetBy(string postalCode);
        IEnumerable<Location> GetAll();
    }
}




namespace Beerhall.Models.Domain {
    public class Location {
        public string PostalCode { get; set; }
        public string Name { get; set; }
    }
}




using System;
using System.Collections.Generic;
using System.Linq;

namespace Beerhall.Models.Domain {
    public class Order {
        #region Fields
        private DateTime? _deliveryDate;
        private string _street;
        private Location _location;
        #endregion

        #region Properties
        public int OrderId { get; private set; } // required for EF
        public DateTime? DeliveryDate {
            get { return _deliveryDate; }
            private set {
                if (value.HasValue) {
                    if (DateTime.Today.AddDays(3) > value.Value)
                        throw new ArgumentException("Date of delivery must at least be three days after placing order");
                    if (value.Value.DayOfWeek == DayOfWeek.Sunday)
                        throw new ArgumentException("Sundays are not valid delivery days");
                }
                _deliveryDate = value;
            }
        }
        public DateTime OrderDate { get; private set; }
        public bool Giftwrapping { get; private set; }
        public string Street {
            get { return _street; }
            private set {
                if (string.IsNullOrWhiteSpace(value))
                    throw new ArgumentException("Street is required");
                _street = value;
            }
        }
        public Location Location {
            get { return _location; }
            private set {
                if (value == null)
                    throw new ArgumentException("Location is required");
                _location = value;
            }
        }
        public ICollection<OrderLine> OrderLines { get; private set; }
        public decimal Total { get { return OrderLines.Sum(o => o.Price * o.Quantity); } }

        #endregion

        #region Constructors
        private Order() {
            OrderLines = new HashSet<OrderLine>();
            OrderDate = DateTime.Today;
        }

        public Order(Cart cart, DateTime? deliveryDate, bool giftwrapping, string street, Location location) : this() {
            if (cart.NumberOfItems == 0)
                throw new ArgumentException("An order requires a non empty cart");
            foreach (CartLine line in cart.CartLines)
                OrderLines.Add(new OrderLine {
                    Product = line.Product,
                    Price = line.Product.Price,
                    Quantity = line.Quantity
                });
            DeliveryDate = deliveryDate;
            Giftwrapping = giftwrapping;
            Street = street;
            Location = location;
        }
        #endregion
    }
}



namespace Beerhall.Models.Domain {
    public class OrderLine : CartLine {
        public int OrderId { get; set; }
        public int ProductId { get; set; }
        public decimal Price { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.AccountViewModels
{
    public class ExternalLoginConfirmationViewModel
    {
        [Required]
        [EmailAddress]
        public string Email { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.AccountViewModels
{
    public class ForgotPasswordViewModel
    {
        [Required]
        [EmailAddress]
        public string Email { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.AccountViewModels
{
    public class LoginViewModel
    {
        [Required]
        [EmailAddress]
        public string Email { get; set; }

        [Required]
        [DataType(DataType.Password)]
        public string Password { get; set; }

        [Display(Name = "Remember me?")]
        public bool RememberMe { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.AccountViewModels
{
    public class RegisterViewModel
    {
        [Required]
        [EmailAddress]
        [Display(Name = "Email")]
        public string Email { get; set; }

        [Required]
        [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
        [DataType(DataType.Password)]
        [Display(Name = "Password")]
        public string Password { get; set; }

        [DataType(DataType.Password)]
        [Display(Name = "Confirm password")]
        [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
        public string ConfirmPassword { get; set; }

        [Required]
        [StringLength(100)]
        public string Name { get; set; }

        [Required]
        [Display(Name = "First name")]
        [StringLength(100)]
        public string FirstName { get; set; }

        [StringLength(100)]
        public string Street { get; set; }

        [Display(Name = "Location")]
        public string PostalCode { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.AccountViewModels
{
    public class ResetPasswordViewModel
    {
        [Required]
        [EmailAddress]
        public string Email { get; set; }

        [Required]
        [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
        [DataType(DataType.Password)]
        public string Password { get; set; }

        [DataType(DataType.Password)]
        [Display(Name = "Confirm password")]
        [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
        public string ConfirmPassword { get; set; }

        public string Code { get; set; }
    }
}



using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc.Rendering;

namespace Beerhall.Models.ViewModels.AccountViewModels
{
    public class SendCodeViewModel
    {
        public string SelectedProvider { get; set; }

        public ICollection<SelectListItem> Providers { get; set; }

        public string ReturnUrl { get; set; }

        public bool RememberMe { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.AccountViewModels
{
    public class VerifyCodeViewModel
    {
        [Required]
        public string Provider { get; set; }

        [Required]
        public string Code { get; set; }

        public string ReturnUrl { get; set; }

        [Display(Name = "Remember this browser?")]
        public bool RememberBrowser { get; set; }

        [Display(Name = "Remember me?")]
        public bool RememberMe { get; set; }
    }
}



using System;
using System.ComponentModel.DataAnnotations;
using Beerhall.Models.Domain;
using Microsoft.AspNetCore.Mvc;

namespace Beerhall.Models.ViewModels.BrewerViewModels {
    public class EditViewModel {
        [HiddenInput]
        public int BrewerId {
            get; set;
        }
        [Required]
        [StringLength(50, ErrorMessage = "{0} may not contain more than 50 characters")]
        public string Name {
            get; set;
        }
        public string Street {
            get; set;
        }
        [Display(Name = "Postal code")]
        public string PostalCode {
            get; set;
        }
        [DataType(DataType.Currency)]
        [Range(0, int.MaxValue, ErrorMessage = "{0} may not be a negative value.")]
        public int? Turnover {
            get; set;
        }
        public string Description {
            get; set;
        }
        [Display(Name = "Email address")]
        [DataType(DataType.EmailAddress)]
        [RegularExpression(@"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,4}", ErrorMessage = "Email address is not valid")]
        public string ContactEmail {
            get; set;
        }
        [Display(Name = "Date established")]
        [DataType(DataType.Date)]
        public DateTime? DateEstablished {
            get; set;
        }

        public EditViewModel() {
        }

        public EditViewModel(Brewer brewer) : this() {
            BrewerId = brewer.BrewerId;
            Name = brewer.Name;
            Street = brewer.Street;
            PostalCode = brewer.Location?.PostalCode;
            ContactEmail = brewer.ContactEmail;
            Description = brewer.Description;
            DateEstablished = brewer.DateEstablished;
            Turnover = brewer.Turnover;
        }
    }
}


using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using Beerhall.Models.Domain;
using Microsoft.AspNetCore.Mvc.Rendering;

namespace Beerhall.Models.ViewModels.CartViewModels {
    public class CheckOutViewModel {
        public SelectList Locations { get; private set; }
        public ShippingViewModel ShippingViewModel { get; set; }
        public CheckOutViewModel(IEnumerable<Location> locations, ShippingViewModel shippingViewModel) {
            Locations = new SelectList(locations,
                nameof(Location.PostalCode),
                nameof(Location.Name),
                shippingViewModel?.PostalCode);
            ShippingViewModel = shippingViewModel;
        }
    }
    public class ShippingViewModel {
        [DataType(DataType.Date)]
        [Display(Name = "Delivery date")]
        public DateTime? DeliveryDate { get; set; }
        [Display(Name = "Gift wrapping")]
        public bool Giftwrapping { get; set; }
        public string Street { get; set; }
        [Display(Name = "Location")]
        public string PostalCode { get; set; }
    }

}



using Beerhall.Models.Domain;
using Microsoft.AspNetCore.Mvc;

namespace Beerhall.Models.ViewModels.CartViewModels {

    public class IndexViewModel {
        [HiddenInput]
        public int BeerId { get; private set; }

        public int Quantity { get; private set; }

        public string Beer { get; private set; }

        public decimal Price { get; private set; }

        public decimal SubTotal { get; private set; }

        public IndexViewModel(CartLine cartLine) {
            BeerId = cartLine.Product.BeerId;
            Quantity = cartLine.Quantity;
            Beer = cartLine.Product.Name;
            Price = cartLine.Product.Price;
            SubTotal = cartLine.Total;
        }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class AddPhoneNumberViewModel
    {
        [Required]
        [Phone]
        [Display(Name = "Phone number")]
        public string PhoneNumber { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class ChangePasswordViewModel
    {
        [Required]
        [DataType(DataType.Password)]
        [Display(Name = "Current password")]
        public string OldPassword { get; set; }

        [Required]
        [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
        [DataType(DataType.Password)]
        [Display(Name = "New password")]
        public string NewPassword { get; set; }

        [DataType(DataType.Password)]
        [Display(Name = "Confirm new password")]
        [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")]
        public string ConfirmPassword { get; set; }
    }
}



using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc.Rendering;

namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class ConfigureTwoFactorViewModel
    {
        public string SelectedProvider { get; set; }

        public ICollection<SelectListItem> Providers { get; set; }
    }
}



namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class FactorViewModel
    {
        public string Purpose { get; set; }
    }
}



using System.Collections.Generic;
using Microsoft.AspNetCore.Identity;

namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class IndexViewModel
    {
        public bool HasPassword { get; set; }

        public IList<UserLoginInfo> Logins { get; set; }

        public string PhoneNumber { get; set; }

        public bool TwoFactor { get; set; }

        public bool BrowserRemembered { get; set; }
    }
}



using System.Collections.Generic;
using Microsoft.AspNetCore.Http.Authentication;
using Microsoft.AspNetCore.Identity;

namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class ManageLoginsViewModel
    {
        public IList<UserLoginInfo> CurrentLogins { get; set; }

        public IList<AuthenticationDescription> OtherLogins { get; set; }
    }
}



namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class RemoveLoginViewModel
    {
        public string LoginProvider { get; set; }
        public string ProviderKey { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class SetPasswordViewModel
    {
        [Required]
        [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
        [DataType(DataType.Password)]
        [Display(Name = "New password")]
        public string NewPassword { get; set; }

        [DataType(DataType.Password)]
        [Display(Name = "Confirm new password")]
        [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")]
        public string ConfirmPassword { get; set; }
    }
}



using System.ComponentModel.DataAnnotations;

namespace Beerhall.Models.ViewModels.ManageViewModels
{
    public class VerifyPhoneNumberViewModel
    {
        [Required]
        public string Code { get; set; }

        [Required]
        [Phone]
        [Display(Name = "Phone number")]
        public string PhoneNumber { get; set; }
    }
}



using System.Threading.Tasks;

namespace Beerhall.Services
{
    public interface IEmailSender
    {
        Task SendEmailAsync(string email, string subject, string message);
    }
}



using System.Threading.Tasks;

namespace Beerhall.Services
{
    public interface ISmsSender
    {
        Task SendSmsAsync(string number, string message);
    }
}



using System.Threading.Tasks;

namespace Beerhall.Services
{
    // This class is used by the application to send Email and SMS
    // when you turn on two-factor authentication in ASP.NET Identity.
    // For more details see this link http://go.microsoft.com/fwlink/?LinkID=532713
    public class AuthMessageSender : IEmailSender, ISmsSender
    {
        public Task SendEmailAsync(string email, string subject, string message)
        {
            // Plug in your email service here to send an email.
            return Task.FromResult(0);
        }

        public Task SendSmsAsync(string number, string message)
        {
            // Plug in your SMS service here to send a text message.
            return Task.FromResult(0);
        }
    }
}