/// <summary>
/// Adds Kund to database, returns boolean if succeed
/// </summary>
public async Task <bool> AddUserAsync(Kund kund) //TODO kan kontrollera om mailen/användarnamnet är unika
{
_context.Kund.Add(kund);
var result = await _context.SaveChangesAsync();
return(result == 1);
}
public async Task <bool> UpdateDishAsync(Matratt dish)
{
_context.Entry(dish).State = EntityState.Modified;
var result = await _context.SaveChangesAsync();
return(result == 1);
}
/// <summary>
/// Adds the order to the database. PremiumUser will get the calculated price based on the discount and bonus points.
/// </summary>
public async Task <Bestallning> AddOrderAsync(string userId, ShoppingCart cart, UserRole role)
{
var kund = await _context.Kund.FirstOrDefaultAsync(u => u.UserId == userId);
if (kund == null)
{
return(null);
}
if (role == UserRole.PremiumUser)
{
// instantiates the int if it's null, meaning this user hasn't had any points before.
// Add the points to the Kund, 10 points per item in the cart.
if (kund.Bonuspoäng == null)
{
kund.Bonuspoäng = 0;
}
if (kund.Bonuspoäng >= 100)
{
kund.Bonuspoäng -= 100;
}
kund.Bonuspoäng += (cart.Products.Count * 10);
}
// Group the products by ID and counting them into new BestallningMatratt objects
var orders = cart.Products
.GroupBy(p => p.MatrattId)
.Select(g => new BestallningMatratt
{
MatrattId = g.First().MatrattId,
Antal = g.Count()
}).ToList();
// Puts the order together
var order = new Bestallning
{
BestallningDatum = DateTime.Now,
KundId = kund.KundId,
Levererad = false,
Totalbelopp = role == UserRole.PremiumUser ? cart.TotalSum(UserRole.PremiumUser) : cart.TotalSum(),
BestallningMatratt = orders
};
// Calculates the points and saves to database
_context.Add(order);
_context.Entry(kund).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(await _context.Bestallning
.Include(b => b.BestallningMatratt)
.Include(b => b.Kund)
.FirstOrDefaultAsync(x => x.KundId == kund.KundId));
}
public async Task <int> AddNewProdukt(Produkt prod)
{
_context.Add(prod);
await _context.SaveChangesAsync();
return(prod.ProduktId);
}
public async Task <IActionResult> OrderCart()
{
if (cartManager.SavedCart.TotalCount == 0)
{
return(RedirectToAction("ViewCart"));
}
ApplicationUser user = await userManager.GetUserAsync(User);
Bestallning cart = await cartManager.GetBestallningAsync(
kundPremium : UserIsPremium,
kundPoints : user.Points);
cart.Kund = user;
user.Points += cart.TotalCount * Bestallning.POINTS_PER_MATRATT;
dbContext.Bestallning.Add(cart);
if (cart.GratisPizzaPris > 0)
{
user.Points -= Bestallning.POINTS_FOR_FREE_FOOD;
}
await dbContext.SaveChangesAsync();
// Reset cart
cartManager.ClearCart();
return(RedirectToAction("ViewOrder", new
{
id = cart.BestallningId,
}));
}
public async Task <ActionResult> PlaceOrder()
{
string sessionString = HttpContext.Session.GetString("Order");
if (sessionString != null)
{
BestallningMatratt orderDish = new BestallningMatratt();
var dishes = JsonConvert.DeserializeObject <List <Matratt> >(sessionString);
var order = await NewOrderAsync(dishes);
foreach (var dish in dishes)
{
if (order.BestallningMatratt.Where(o => o.MatrattId == dish.MatrattId).Count() == 0)
{
orderDish = new BestallningMatratt {
MatrattId = dish.MatrattId, Antal = 1
};
order.BestallningMatratt.Add(orderDish);
}
else
{
order.BestallningMatratt.Single(o => o.MatrattId == dish.MatrattId).Antal++;
}
}
// Change to altered prices, depending on bonus points and how many dishes
var user = await GetCurrentUserAsync();
if (User.IsInRole("Premium"))
{
if (user.Points == null)
{
user.Points = 0;
}
user.Points += 10 * dishes.Count;
if (user.Points >= 100)
{
order.Totalbelopp -= dishes.Max(d => d.Pris);
user.Points -= 100;
}
if (dishes.Count >= 3)
{
order.Totalbelopp = (int)(order.Totalbelopp * 0.8);
}
}
_context.Add(order);
await _context.SaveChangesAsync();
HttpContext.Session.Remove("Order");
return(View("ThankYou"));
}
else
{
return(RedirectToAction("Cart"));
}
}
public async Task <bool> UpdateCustomerAsync(Kund customer)
{
var getCustResult = await(from cust in _context.Kund
where cust.IdentityId == customer.IdentityId
select cust).SingleOrDefaultAsync();
if (getCustResult == null)
{
return(false);
}
var result = await _context.SaveChangesAsync();
return(await Task.FromResult(result == 1));
}
public async Task <bool> AddIngredient(int dishID, int ingredientID)
{
var result = false;
var dishIngredient = new MatrattProdukt
{
MatrattId = dishID,
ProduktId = ingredientID
};
var ingredientExists = _context.MatrattProdukt
.Any(x => x.MatrattId == dishID && x.ProduktId == ingredientID);
if (ingredientExists == false)
{
_context.MatrattProdukt.Add(dishIngredient);
await _context.SaveChangesAsync();
result = true;
return(result);
}
return(result);
}
public async Task <IActionResult> Register(RegistrationViewModel user)
{
if (ModelState.IsValid)
{
var userIdentity = new ApplicationUser
{
UserName = user.AnvandarNamn
};
var result = await _userManager.CreateAsync(userIdentity, user.Losenord);
if (result.Succeeded)
{
if (user.RoleName == "Premium")
{
var resultRole = await _userManager.AddToRoleAsync(userIdentity, user.RoleName);
}
else
{
var resultRole = await _userManager.AddToRoleAsync(userIdentity, "Regular");
}
var reguser = new Kund
{
Namn = user.Namn,
Gatuadress = user.Gatuadress,
Postnr = user.Postnr,
Postort = user.Postort,
Email = user.Email,
Telefon = user.Telefon,
AnvandarNamn = user.AnvandarNamn,
Losenord = user.Losenord,
IdentityId = userIdentity.Id
};
_tomasos.Add(reguser);
await _tomasos.SaveChangesAsync();
await _signInManager.SignInAsync(userIdentity, isPersistent : false);
return(RedirectToAction("StartPage", "Home"));
}
}
return(View());
}
public async Task <IActionResult> Index(UserRegisterModel model)
{
// Ignore properties
ModelState.Remove(nameof(model.UserName));
ModelState.Remove(nameof(model.Password));
ModelState.Remove(nameof(model.PasswordConfirm));
ApplicationUser currentUser = await userManager.GetUserAsync(User);
if (ModelState.IsValid)
{
// Update user
model.UserName = currentUser.UserName;
model.ApplyToApplicationUser(currentUser);
await dbContext.SaveChangesAsync();
}
return(View(new UserRegisterModel(currentUser)));
}
private async Task CreateUserRoles(IServiceProvider serviceProvider)
{
var RoleManager = serviceProvider.GetRequiredService <RoleManager <IdentityRole> >();
var UserManager = serviceProvider.GetRequiredService <UserManager <ApplicationUser> >();
IdentityResult roleResult;
IdentityResult roleResult2;
IdentityResult roleResult3;
//Adding Admin Role
var roleCheck = await RoleManager.RoleExistsAsync("Admin");
if (!roleCheck)
{
//create the roles and seed them to the database
roleResult = await RoleManager.CreateAsync(new IdentityRole("Admin"));
}
var roleCheck2 = await RoleManager.RoleExistsAsync("Premium");
if (!roleCheck2)
{
//create the roles and seed them to the database
roleResult2 = await RoleManager.CreateAsync(new IdentityRole("Premium"));
}
var roleCheck3 = await RoleManager.RoleExistsAsync("Regular");
if (!roleCheck3)
{
//create the roles and seed them to the database
roleResult3 = await RoleManager.CreateAsync(new IdentityRole("Regular"));
}
if (await UserManager.FindByNameAsync("Admin") == null)
{
var userIdentity = new ApplicationUser
{
UserName = "******"
};
var result = await UserManager.CreateAsync(userIdentity, "Admin123");
if (result.Succeeded)
{
var resultRole = await UserManager.AddToRoleAsync(userIdentity, "Admin");
var reguser = new Kund
{
Namn = "Admin",
Gatuadress = "Admin",
Postnr = "Admin",
Postort = "Admin",
Email = "Admin",
Telefon = "Admin",
AnvandarNamn = "Admin",
Losenord = "Admin123",
IdentityId = userIdentity.Id
};
TomasosContext DB = new TomasosContext();
DB.Add(reguser);
await DB.SaveChangesAsync();
}
}
}
public async Task Add(T entity)
{
await _context.Set <T>().AddAsync(entity);
await _context.SaveChangesAsync();
}