public async Task <IActionResult> Edit(int id, [Bind("TasterId,TasterName,TasterEmail,TasterSecondName")] Taster taster)
{
if (id != taster.TasterId)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(taster);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TasterExists(taster.TasterId))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(taster));
}
public bool CheckAndReportLogin()
{
CurrentTaster = SessionHelper.Instance().GetTaster();
if (CurrentTaster == null || CurrentTaster.TasterId == -1)
{
TempData["CustomError"] = "You must be logged in";
return(false);
}
return(true);
}
public IActionResult OnPostLogout()
{
var taster = new Taster()
{
DisplayName = string.Empty,
EmailAddress = string.Empty,
IsAdmin = false,
TasterId = -1,
};
SessionHelper.Instance().SaveTaster(taster);
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Taster = await _context.Taster.FindAsync(id);
if (Taster != null)
{
_context.Taster.Remove(Taster);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task <IActionResult> Create([Bind("TasterId,TasterName,TasterEmail,TasterSecondName")] Taster taster, string password)
{
if (ModelState.IsValid)
{
var result = await _userAccessService.RegisterUserFromForm(taster.TasterEmail, password);
if (!result)
{
return(RedirectToAction("ErrorPage", "Home", new { message = "Something going wrong. Please check that user can exist already." }));
}
_context.Add(taster);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(taster));
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (CheckAndReportAdmin())
{
return(Page());
}
if (id == null)
{
return(NotFound());
}
Taster = await _context.Taster.FirstOrDefaultAsync(m => m.TasterId == id);
if (Taster == null)
{
return(NotFound());
}
return(Page());
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var taster = new Taster()
{
EmailAddress = this.EmailAddress,
DisplayName = this.DisplayName,
Password = this.Password,
};
if (CheckAndReportLogin())
{
return(Page());
}
if (taster.EmailAddress.ToLower().Contains("bouvet.no") == false)
{
TempData["CustomError"] = "You're not allowed to register here with that e-mail address";
return(OnGet());
}
if (_context.Taster.Any(x => x.EmailAddress.ToLower() == taster.EmailAddress.ToLower()))
{
TempData["CustomError"] = "E-mail is already registered";
return(OnGet());
}
taster.IsAdmin = taster.EmailAddress.ToLower().Equals("*****@*****.**");
_context.Taster.Add(taster);
await _context.SaveChangesAsync();
SessionHelper.Instance().SaveTaster(taster);
SessionHelper.Instance().GetTaster();
return(RedirectToPage("./Index"));
}
public BeerPageModel(TastingContext context) : base()
{
_context = context;
CurrentTaster = SessionHelper.Instance().GetTaster();
}
public static void Seed(TastingContext context)
{
context.Database.EnsureCreated();
if (context.Beer.Any())
{
return;
}
var beerClasses = new List <string>()
{
"Regular",
"Homebrew",
"High ABV"
};
var classes = new List <BeerClass>();
for (var i = 0; i < beerClasses.Count; i++)
{
classes.Add(new BeerClass()
{
Name = beerClasses[i]
});
}
context.Beerclass.AddRange(classes);
context.SaveChanges();
var styleNames = new List <string>()
{
"Alternative Grain Beer",
"Alternative Sugar Beer",
"American Amber Ale",
"American Barleywine",
"American Brown Ale",
"American IPA",
"American Lager",
"Altbier",
"American Light Lager",
"American Pale Ale",
"American Porter",
"American Stout",
"American Strong Ale",
"American Wheat Beer",
"American Wheat or Rye Beer",
"Apple Wine",
"Australian Sparkling Ale",
"Autumn Seasonal Beer",
"Baltic Porter",
"Belgian Blond Ale",
"Belgian Dark Strong Ale",
"Belgian Dubbel",
"Belgian Golden Strong Ale",
"Belgian Pale Ale",
"Belgian Specialty Ale",
"Belgian Tripel",
"Berliner Weisse",
"Best Bitter",
"Bière de Garde",
"Blonde Ale",
"Bohemian Pilsener",
"Braggot",
"Brett Beer",
"British Brown Ale",
"British Golden Ale",
"British Strong Ale",
"Brown Porter",
"Burton Ale",
"California Common",
"California Common Beer",
"Catharina Sour",
"Classic American Pilsner",
"Classic Rauchbier",
"Classic Style Smoked Beer",
"Clone Beer",
"Common Cider",
"Common Perry",
"Cream Ale",
"Cyser (Apple Melomel)",
"Czech Amber Lager",
"Czech Dark Lager",
"Czech Pale Lager",
"Czech Premium Pale Lager",
"Dark American Lager",
"Dark Mild",
"Doppelbock",
"Dortmunder Export",
"Double IPA",
"Dry Mead",
"Dry Stout",
"Dunkelweizen",
"Dunkles Bock",
"Dunkles Weissbier",
"Düsseldorf Altbier",
"Eisbock",
"English Barleywine",
"English Cider",
"English IPA",
"English Porter",
"Experimental Beer",
"Extra Special/Strong Bitter (ESB)",
"Festbier",
"Flanders Brown Ale/Oud Bruin",
"Flanders Red Ale",
"Foreign Extra Stout",
"French Cider",
"Fruit and Spice Beer",
"Fruit Beer",
"Fruit Cider",
"Fruit Lambic",
"German Helles Exportbier",
"German Leichtbier",
"German Pils",
"German Pilsner (Pils)",
"Gose",
"Gueuze",
"Helles Bock",
"Holiday/Winter Special Spiced Beer",
"Imperial IPA",
"Imperial Stout",
"International Amber Lager",
"International Dark Lager",
"International Pale Lager",
"Irish Extra Stout",
"Irish Red Ale",
"Irish Stout",
"Kellerbier: Amber Kellerbier",
"Kellerbier: Pale Kellerbier",
"Kentucky Common",
"Kölsch",
"Lambic",
"Lichtenhainer",
"Light American Lager",
"London Brown Ale",
"Maibock/Helles Bock",
"Märzen",
"Metheglin",
"Mild",
"Mixed-Fermentation Sour Beer",
"Mixed-Style Beer",
"Munich Dunkel",
"Munich Helles",
"New England Cider",
"New Zealand Pilsner",
"No Profile Selected",
"North German Altbier",
"Northern English Brown",
"Oatmeal Stout",
"Oktoberfest/Märzen",
"Old Ale",
"Open Category Mead",
"Ordinary Bitter",
"Other Fruit Melomel",
"Other Smoked Beer",
"Other Specialty Cider or Perry",
"Oud Bruin",
"Piwo Grodziskie",
"Pre-Prohibition Lager",
"Pre-Prohibition Porter",
"Premium American Lager",
"Pyment (Grape Melomel)",
"Rauchbier",
"Robust Porter",
"Roggenbier",
"Roggenbier (German Rye Beer)",
"Russian Imperial Stout",
"Sahti",
"Saison",
"Schwarzbier",
"Scottish Export",
"Scottish Export 80/-",
"Scottish Heavy",
"Scottish Heavy 70/-",
"Scottish Light",
"Scottish Light 60/-",
"Semi-Sweet Mead",
"Southern English Brown",
"Special/Best/Premium Bitter",
"Specialty Beer",
"Specialty Fruit Beer",
"Specialty IPA: Belgian IPA",
"Specialty IPA: Black IPA",
"Specialty IPA: Brown IPA",
"Specialty IPA: New England IPA",
"Specialty IPA: Red IPA",
"Specialty IPA: Rye IPA",
"Specialty IPA: White IPA",
"Specialty Smoked Beer",
"Specialty Wood-Aged Beer",
"Spice, Herb, or Vegetable Beer",
"Standard American Lager",
"Standard/Ordinary Bitter",
"Straight (Unblended) Lambic",
"Strong Bitter",
"Strong Scotch Ale",
"Sweet Mead",
"Sweet Stout",
"Traditional Bock",
"Traditional Perry",
"Trappist Single",
"Tropical Stout",
"Vienna Lager",
"Wee Heavy",
"Weissbier",
"Weizen/Weissbier",
"Weizenbock",
"Wheatwine",
"Wild Specialty Beer",
"Winter Seasonal Beer",
"Witbier",
"Wood-Aged Beer"
};
var beerStyles = new List <Beerstyle>();
for (var i = 0; i < styleNames.Count; i++)
{
beerStyles.Add(new Beerstyle()
{
Name = styleNames[i]
});
}
context.Beerstyle.AddRange(beerStyles);
context.SaveChanges();
var breweries = new List <Brewery>()
{
new Brewery()
{
Name = "Nøgne Ø (Hansa Borg)",
Country = "Norway",
Website = "https://www.nogne-o.com/"
},
new Brewery()
{
Name = "Brasserie de la Senne",
Country = "Belgium",
Website = "http://brasseriedelasenne.be/"
}
};
context.Brewery.AddRange(breweries);
context.SaveChanges();
var beers = new List <Beer>()
{
new Beer()
{
ABV = 8.5f,
BreweryId = 1,
Name = "Nøgne Ø Two Captains Double IPA",
RateBeerLink = "https://www.ratebeer.com/beer/nogne-o-two-captains-double-ipa/125773",
BeerStyleId = 1
},
new Beer()
{
ABV = 9.0f,
BreweryId = 1,
Name = "Nøgne Ø Imperial Stout",
RateBeerLink = "https://www.ratebeer.com/beer/nogne-o-imperial-stout/49092/",
BeerStyleId = 2
},
new Beer()
{
ABV = 6.3f,
BreweryId = 2,
Name = "Two Roads Brothers In Farms",
RateBeerLink = "https://www.ratebeer.com/beer/de-la-senne-two-roads-brothers-in-farms/535109/",
BeerStyleId = 3
},
new Beer()
{
ABV = 5.5f,
BreweryId = 2,
Name = "Betchard Blonde (2006)",
RateBeerLink = "https://www.ratebeer.com/beer/betchard-blonde-2006/55996/",
BeerStyleId = 4
},
new Beer()
{
ABV = 10.0f,
BreweryId = 2,
Name = "Liquid Riot Jambe d’Érable",
RateBeerLink = "https://www.ratebeer.com/beer/de-la-senne-liquid-riot-jambe-d%E2%80%99erable/658854/",
BeerStyleId = 15
}
};
context.Beer.AddRange(beers);
context.SaveChanges();
var tastings = new List <Tasting>()
{
new Tasting()
{
Name = "Bouvet juleølsmaking 2017",
Description = "Årlig juleølsmaking for Bouvet Nord",
IsActive = false,
IsBlind = false
},
new Tasting()
{
Name = "Bouvet juleølsmaking 2018",
Description = "Årlig juleølsmaking for Bouvet Nord",
IsActive = true,
IsBlind = false
},
new Tasting()
{
Name = "Bouvet blinde juleølsmaking 2018",
Description = "Årlig juleølsmaking for Bouvet Nord",
IsActive = true,
IsBlind = true
}
};
context.Tasting.AddRange(tastings);
context.SaveChanges();
var tastingBeers = new List <TastingBeer>()
{
new TastingBeer()
{
BeerId = 1,
TastingId = 2,
SortOrder = 1
},
new TastingBeer()
{
BeerId = 2,
TastingId = 2,
SortOrder = 2
},
new TastingBeer()
{
BeerId = 3,
TastingId = 2,
SortOrder = 3
},
new TastingBeer()
{
BeerId = 4,
TastingId = 2,
SortOrder = 5
},
new TastingBeer()
{
BeerId = 5,
TastingId = 2,
SortOrder = 4
}
};
context.TastingBeer.AddRange(tastingBeers);
context.SaveChanges();
var tasterAdmin = new Taster()
{
DisplayName = "Andreas",
EmailAddress = "*****@*****.**",
Password = "******",
IsAdmin = true
};
var tasterNotAdmin = new Taster()
{
DisplayName = "Andreas",
EmailAddress = "*****@*****.**",
Password = "******",
IsAdmin = false
};
context.Taster.Add(tasterAdmin);
context.Taster.Add(tasterNotAdmin);
context.SaveChanges();
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new IdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var roleCheck = false;
switch (Input.Email)
{
case "*****@*****.**":
roleCheck = await _roleManager.RoleExistsAsync("Laboratory");
if (!roleCheck)
{
await _roleManager.CreateAsync(new IdentityRole("Laboratory"));
}
await _userManager.AddToRoleAsync(user, "Laboratory");
break;
case "*****@*****.**":
roleCheck = await _roleManager.RoleExistsAsync("CEO");
if (!roleCheck)
{
await _roleManager.CreateAsync(new IdentityRole("CEO"));
}
await _userManager.AddToRoleAsync(user, "CEO");
break;
default:
roleCheck = await _roleManager.RoleExistsAsync("Taster");
if (!roleCheck)
{
await _roleManager.CreateAsync(new IdentityRole("Taster"));
}
await _userManager.AddToRoleAsync(user, "Taster");
if (await _userManager.IsInRoleAsync(user, "Taster"))
{
var taster = new Taster {
TasterEmail = Input.Email, TasterName = Input.FirstName, TasterSecondName = Input.SecondName
};
_context.Add(taster);
await _context.SaveChangesAsync();
}
break;
}
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
