public bool UpdateUser(UpdateInfoModel updatedInfoModel, WebshopUser userToUpdate, ShippingAddress address)
{
userToUpdate.Email = updatedInfoModel.Email;
userToUpdate.FirstName = updatedInfoModel.FirstName;
userToUpdate.LastName = updatedInfoModel.LastName;
userToUpdate.PhoneNumber = updatedInfoModel.PhoneNumber;
bool addressChanged = updatedInfoModel.PostalCode != address.PostalCode ||
updatedInfoModel.StreetNumber != address.StreetNumber ||
updatedInfoModel.StreetName != address.StreetName ||
updatedInfoModel.CityName != address.CityName;
if (addressChanged)
{
ShippingAddress userAddress = new ShippingAddress
{
PostalCode = updatedInfoModel.PostalCode,
StreetNumber = updatedInfoModel.StreetNumber,
StreetName = updatedInfoModel.StreetName,
CityName = updatedInfoModel.CityName,
Country = updatedInfoModel.Country,
Province = updatedInfoModel.Province,
AssociatedUser = userToUpdate.UserGuid
};
userToUpdate.ShippingAddresses = new List <ShippingAddress>(new ShippingAddress[] { userAddress });
}
context.SaveChanges();
return(addressChanged);
}
public async Task <string> GenerateTokenLogin(WebshopUser user)
{
List <Claim> claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Sub, user.Email),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(ClaimTypes.Sid, user.Id),
new Claim(ClaimTypes.Name, user.FirstName),
new Claim(ClaimTypes.UserData, user.UserGuid.ToString())
};
IList <Claim> userClaims = await userManager.GetClaimsAsync(user);
SymmetricSecurityKey key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(config["Token:Key"]));
SigningCredentials credentials = new SigningCredentials(key, SecurityAlgorithms.HmacSha512);
JwtSecurityToken securityToken = new JwtSecurityToken(
config["Token:Issuer"],
config["Token:Issuer"],
claims,
expires: DateTime.UtcNow.AddHours(24),
signingCredentials: credentials);
return(new JwtSecurityTokenHandler().WriteToken(securityToken));
}
public async Task <IActionResult> GetUserOrders()
{
string userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid).Value;
WebshopUser user = await UserManager.FindByIdAsync(userId);
if (user != null)
{
List <OrderOverviewModel> orders = OrderRepository.GetAllUserOrders(user.UserGuid);
// Can be done in subquery in repository but this also works
foreach (OrderOverviewModel order in orders)
{
order.Products = new List <ProductOverviewModel>();
foreach (ProductOrder productOrder in order.OrderedProducts)
{
order.Products.Add(ProductRepository.GetOverviewModel(productOrder));
}
// Set the null to erase duplicate data
order.OrderedProducts = null;
}
return(Ok(new { orders }));
}
else
{
return(BadRequest());
}
}
public async Task <IActionResult> AdminCheck()
{
string userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid)?.Value;
WebshopUser user = await UserManager.FindByIdAsync(userId);
return(Ok(new { user.isAdmin }));
}
public async Task <IActionResult> Login([FromBody] LoginViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
LoginResponse loginResponse = new LoginResponse();
WebshopUser user = await UserManager.FindByEmailAsync(model.Email);
if (user != null)
{
Microsoft.AspNetCore.Identity.SignInResult result =
await SignInManager.CheckPasswordSignInAsync(user, model.Password, true);
if (result.Succeeded)
{
string token = await TokenGenerator.GenerateTokenLogin(user);
loginResponse.Success = true;
loginResponse.Token = token;
return(Ok(new { loginResponse }));
}
loginResponse.Success = false;
return(Ok(new { loginResponse }));
}
loginResponse.Success = false;
loginResponse.Error = "User could not be found. Or Password does not match login.";
return(Ok(new { loginResponse }));
}
public void Delete(string id)
{
WebshopUser userToDelete = UserRepository.FindById(id);
AddressRepository.DeleteAddress(userToDelete.UserGuid);
UserRepository.DeleteUser(userToDelete);
}
public IActionResult GetUserInformation(string id)
{
WebshopUser user = UserRepository.FindById(id);
ShippingAddress address = AddressRepository.GetByGuid(user.UserGuid);
user.ShippingAddresses = new List <ShippingAddress>(new[] { address });
return(Json(new { user }));
}
public async Task <IActionResult> AddOrder([FromBody] OrderUserViewModel model)
{
if (ModelState.IsValid)
{
string userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid).Value;
WebshopUser user = await UserManager.FindByIdAsync(userId);
if (user != null)
{
decimal totalPriceOrder = CalculateOrderPrice(model.Products);
List <ProductOrder> productOrders = GetOrderProducts(model.Products);
decimal finalPrice = totalPriceOrder;
decimal discount = 0;
if (model.Coupon != null)
{
var discountValidation = ValidateCouponCode(model.Coupon, totalPriceOrder);
if (discountValidation != null)
{
model.Coupon = discountValidation.Item1;
discount = discountValidation.Item2;
finalPrice = discountValidation.Item3;
}
}
Order newOrder = new Order
{
Guid = Guid.NewGuid(),
Paid = false,
Shipped = false,
OrderCreated = DateTime.Now,
TotalPrice = totalPriceOrder,
Discount = discount,
FinalPrice = finalPrice,
CouponCode = model.Coupon,
OrderedProducts = productOrders,
AssociatedUserGuid = user.UserGuid,
OrderedFromGuestAccount = false,
EmailConfirmationSent = false,
OrderStatus = OrderStatus.Received
};
OrderRepository.AddOrder(newOrder);
return(Ok(newOrder.Guid));
}
}
return(BadRequest());
}
public async Task <IActionResult> Register([FromBody] RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
WebshopUser newUser = new WebshopUser
{
UserGuid = Guid.NewGuid(),
UserName = model.Email,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
FavoriteLists = new List <FavoriteList>(),
DateCreated = DateTime.Now
};
ShippingAddress userAddress = new ShippingAddress
{
PostalCode = model.PostalCode,
StreetNumber = model.StreetNumber,
StreetName = model.StreetName,
CityName = model.CityName,
Country = model.Country,
Province = model.Province,
AssociatedUser = newUser.UserGuid
};
newUser.PhoneNumber = model.PhoneNumber;
newUser.ShippingAddresses = new List <ShippingAddress>(new[] { userAddress });
IdentityResult registerResult = await UserManager.CreateAsync(newUser, model.Password);
RegisterResponse registerResponse = new RegisterResponse();
if (registerResult.Succeeded)
{
registerResponse.Success = true;
MailService.SendWelcomeEmail(model.FirstName, model.LastName, model.Email);
return(Ok(new { registerResponse }));
}
List <string> errors = registerResult.Errors.Select(error => error.Description).ToList();
registerResponse.Success = false;
registerResponse.Errors = errors;
return(Ok(new { registerResponse }));
}
public async Task <IActionResult> GetAccountInformation()
{
string userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid)?.Value;
WebshopUser user = await UserManager.FindByIdAsync(userId);
if (user == null)
{
return(BadRequest());
}
ShippingAddress address = AddressRepository.GetByGuid(user.UserGuid);
return(Ok(new
{
address, email = user.Email, name = user.FirstName, lastName = user.LastName,
phone = user.PhoneNumber
}));
}
public async void Update([FromBody] UpdateInfoModel updatedInfoModel, string id)
{
WebshopUser userToUpdate = UserRepository.FindById(id);
if (userToUpdate.Email != updatedInfoModel.Email)
{
string token = await UserManager.GenerateChangeEmailTokenAsync(userToUpdate, updatedInfoModel.Email);
await UserManager.ChangeEmailAsync(userToUpdate, updatedInfoModel.Email, token);
}
ShippingAddress address = AddressRepository
.GetByGuid(userToUpdate.UserGuid);
bool addressChanged = UserRepository.UpdateUser(updatedInfoModel, userToUpdate, address);
if (addressChanged)
{
AddressRepository.DeleteAddress(userToUpdate.UserGuid);
}
}
public async Task <IActionResult> UpdateAccountInformation([FromBody] UpdateInfoModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
string userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.Sid)?.Value;
WebshopUser user = await UserManager.FindByIdAsync(userId);
ShippingAddress currentAddress = AddressRepository.GetByGuid(user.UserGuid);
if (model.PostalCode != currentAddress.PostalCode)
{
ShippingAddress userAddress = new ShippingAddress
{
PostalCode = model.PostalCode,
StreetNumber = model.StreetNumber,
StreetName = model.StreetName,
CityName = model.CityName,
Country = model.Country,
Province = model.Province,
AssociatedUser = user.UserGuid
};
AddressRepository.DeleteAddress(user.UserGuid);
user.ShippingAddresses = new List <ShippingAddress>(new[] { userAddress });
}
user.PhoneNumber = model.PhoneNumber;
user.FirstName = model.FirstName;
user.LastName = model.LastName;
IdentityResult result = await UserManager.UpdateAsync(user);
if (result.Succeeded)
{
return(Ok());
}
return(BadRequest());
}
public Task <string> GenerateTokenReset(WebshopUser user)
{
throw new NotImplementedException();
}
public void DeleteUser(WebshopUser user)
{
context.Users.Remove(user);
context.SaveChanges();
}
