public async Task <IActionResult> Register([FromBody] RegisterRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new UserAccount
{
UserName = model.Username,
Email = model.Email,
IsBlocked = false,
Firstname = model.FirstName,
Lastname = model.LastName,
PhoneNumber = model.PhoneNumber
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _userManager.AddToRoleAsync(user, UserRoleString.User);
await _signInManager.SignInAsync(user, false);
return(Ok(JWTtoken.Generate(_configuration, model.Username, user)));
}
return(BadRequest(result.Errors.First().Description));
}
public IActionResult AddItem([FromBody] ShoppingCartDto item)
{
_logger.LogInformation("Hello from dummy controller!");
//_logger.LogInformation("User name: " + User.Identity.Name + "User role: " + User.Identity.ToString() + "Time: " + DateTime.Now.ToString("h:mm:ss tt") + "ShoppingCartController:CheckIfUserHasShoppingCart()");
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (item.itemQuantity == 0)
{
return(NoContent());
}
var userName = JWTtoken.GetTokenInfo(Request, "sub");
if (userName == null)
{
return(NotFound("Could not get token"));
}
var itemFromDb = _itemsRepository.GetItem(item.itemId);
if (itemFromDb == null)
{
return(NotFound("Item with given id not found"));
}
var shoppingCart = _shoppingCartRepository.Get(userName);
_shoppingCartRepository.Add(shoppingCart, itemFromDb.Id, item.itemQuantity);
return(Ok("Item(s) added successfully"));
}
public async Task <IActionResult> Login([FromBody] LoginRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await _signInManager.PasswordSignInAsync(model.Username, model.Password, false, false);
if (result.Succeeded)
{
var appUser = _userManager.Users.SingleOrDefault(r => r.UserName == model.Username);
if (appUser.IsBlocked)
{
return(StatusCode((int)HttpStatusCode.Unauthorized, new ErrorResponse
{
Message = "Your account is blocked for indefinite ammount of time"
}));
}
var userRoles = await _userManager.GetRolesAsync(appUser);
var role = userRoles.Contains(UserRoles.Admin.ToString())
? UserRoles.Admin
: UserRoles.User;
return(Ok(JWTtoken.Generate(_configuration, model.Username, appUser, role)));
}
return(StatusCode((int)HttpStatusCode.Unauthorized, new ErrorResponse
{
Message = "Username and password doesn't match"
}));
}
public async Task <IActionResult> Update_Info([FromBody] UpdateUserInfoRequest model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var username = JWTtoken.GetUsernameFromToken(Request);
if (username == null)
{
return(NotFound());
}
var emailIsUsed = _userManager.Users.Any(user => user.Email.Equals(model.Email) && !user.UserName.Equals(username));
if (emailIsUsed)
{
return(BadRequest($"Email {model.Email} is already taken"));
}
var userAccount = await _userManager.FindByNameAsync(username);
userAccount.Email = model.Email;
userAccount.Firstname = model.FirstName;
userAccount.Lastname = model.LastName;
userAccount.PhoneNumber = model.PhoneNumber;
var result = await _userManager.UpdateAsync(userAccount);
if (result.Succeeded)
{
return(Ok("User updated successfully"));
}
return(NotFound());
}
public async Task <IActionResult> GetMe()
{
var accName = JWTtoken.GetUsernameFromToken(Request);
if (accName == null)
{
return(Unauthorized());
}
var account = await _userManager.FindByNameAsync(accName);
if (account == null)
{
return(NotFound());
}
var response = new UserSelfInfoResponse
{
Email = account.Email,
Firstname = account.Firstname,
Lastname = account.Lastname,
PhoneNumber = account.PhoneNumber
};
return(Ok(response));
}
public IActionResult CheckIfUserHasShoppingCart()
{
//_logger.LogInformation("User name: " + User.Identity.Name + "User role: " + User.Identity.ToString() + "Time: " + DateTime.Now.ToString("h:mm:ss tt") + "ShoppingCartController:CheckIfUserHasShoppingCart()");
var userName = JWTtoken.GetTokenInfo(Request, "sub");
if (userName == null)
{
return(NotFound("Wrong credentials"));
}
var shoppingCart = _shoppingCartRepository.Get(userName);
return(Ok(shoppingCart.ShoppingCartItems != null));
}
public IActionResult Update([FromBody] List <ShoppingCartDto> items)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var username = JWTtoken.GetTokenInfo(Request, "sub");
if (username == null)
{
return(NotFound("Could not get token"));
}
ShoppingCart cart = _shoppingCartRepository.Get(username);
List <ShoppingCartItem> shoppingCartItems = new List <ShoppingCartItem>();
if (items.Count == 0)
{
_shoppingCartRepository.Delete(username);
}
else
{
foreach (var item in items)
{
var itemFromDb = _itemsRepository.GetItem(item.itemId);
if (itemFromDb == null)
{
return(NotFound("Item with given id not found"));
}
var newItem = new ShoppingCartItem
{
ItemId = item.itemId,
Quantity = item.itemQuantity
};
shoppingCartItems.Add(newItem);
}
cart.ShoppingCartItems = shoppingCartItems;
_shoppingCartRepository.Update(cart);
_shoppingCartItemsRepository.DeleteOrphans();
}
return(Ok("Item(s) updated successfully"));
}
public async Task <IActionResult> AddReview([FromBody] ReviewDto reviewData)
{
//reviewData.orderId here will not be sent
if (reviewData.Stars < 1 || reviewData.Stars > 5)
{
return(BadRequest("Star evaluation missing or is in incorrect format"));
}
var username = JWTtoken.GetUsernameFromToken(Request);
if (username == null)
{
return(BadRequest());
}
var acc = await _accountManager.FindByNameAsync(username);
var newestOrder = _ordersRepository.GetUserPurchaseHistory(acc.Id)
.OrderByDescending(order => order.Date)
.FirstOrDefault();
if (newestOrder == null)
{
return(BadRequest("Order not found"));
}
if (_reviewsRepository.GetById(newestOrder.Id) != null)
{
return(BadRequest("This order already has a review"));
}
Review newReview = new Review
{
Id = newestOrder.Id,
Description = reviewData.Description,
Stars = reviewData.Stars
};
Review addedReview = _reviewsRepository.Add(newReview);
if (addedReview == null)
{
return(BadRequest("Review could not be added"));
}
return(Ok("Review added successfully"));
}
public IActionResult Delete()
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var username = JWTtoken.GetTokenInfo(Request, "sub");
if (username == null)
{
return(NotFound("Could not get token"));
}
_shoppingCartRepository.Delete(username);
return(Ok("Item deleted successfully"));
}
public IActionResult Get()
{
//_logger.LogInformation("User name: " + User.Identity.Name + "User role: " + User.Identity.ToString() + "Time: " + DateTime.Now.ToString("h:mm:ss tt") + "ShoppingCartController:CheckIfUserHasShoppingCart()");
var userName = JWTtoken.GetTokenInfo(Request, "sub");
if (userName == null)
{
return(NotFound("Wrong credentials"));
}
var shoppingCart = _shoppingCartRepository.Get(userName);
if (shoppingCart == null)
{
return(NoContent());
}
if (shoppingCart.ShoppingCartItems == null)
{
return(NoContent());
}
if (shoppingCart.ShoppingCartItems.Count == 0)
{
return(NoContent());
}
var response = new List <ShoppingCartItemResponse>();
foreach (var item in shoppingCart.ShoppingCartItems)
{
var newItem = new ShoppingCartItemResponse()
{
Id = item.ItemId,
ImagePath = item.Item.PictureLocation,
Price = item.Item.Cost,
Quantity = item.Quantity,
Title = item.Item.Title
};
response.Add(newItem);
}
return(Ok(response));
}
public async Task <IActionResult> GetPurchaseHistory()
{
var username = JWTtoken.GetUsernameFromToken(Request);
if (username == null)
{
return(NotFound());
}
var user = await _accountManager.FindByNameAsync(username);
if (user == null)
{
return(NotFound());
}
var list = _ordersRepository.GetUserPurchaseHistory(user.Id).ToList();
if (list.Count() != 0)
{
List <ShoppingHistoryItemResponse> purchases = list.Select(order => new ShoppingHistoryItemResponse
{
Id = order.Id,
Date = order.Date,
Items = order.Items,
Cost = order.Cost
})
.ToList();
return(Ok(purchases));
}
else
{
return(NotFound("Purchase history is empty!"));
}
}
public async Task <IActionResult> Change_Password([FromBody] ChangePasswordRequest request)
{
if (string.IsNullOrEmpty(request.CurrentPassword) || string.IsNullOrEmpty(request.NewPassword))
{
return(BadRequest("Please fill all the fields"));
}
var username = JWTtoken.GetUsernameFromToken(Request);
if (username == null)
{
return(NotFound());
}
var user = await _userManager.FindByNameAsync(username);
var result = await _userManager.ChangePasswordAsync(user, request.CurrentPassword, request.NewPassword);
if (result.Succeeded)
{
return(Ok("Password changed successfully"));
}
return(BadRequest(result.Errors.First().Description));
}
public JWTAuthenticate(IOptions <JWTtoken> token)
{
jwtToken = token.Value;
}
public IActionResult HandlePurchase([FromBody] PaymentRequest paymentInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//validating body
if (paymentInfo.Amount <= 0)
{
return(BadRequest("Amount to pay must is invalid")); //change request code
}
if (!ValidCreditCardNumber(paymentInfo.Number))
{
return(BadRequest("Credit card info is invalid"));
}
if (paymentInfo.Holder.Length < 2 || paymentInfo.Holder.Length > 32)
{
return(BadRequest("Card holder name is invalid"));
}
if (paymentInfo.Exp_Year < 1970)
{
return(BadRequest("Card expiration year is invalid"));
}
if (paymentInfo.Exp_Month < 1 || paymentInfo.Exp_Month > 12)
{
return(BadRequest("Card expiration month is invalid"));
}
if (!ValidCvv(paymentInfo.Cvv))
{
return(BadRequest("Card cvv security code is invalid"));
}
//get user for further information
var username = JWTtoken.GetUsernameFromToken(Request);
var user = _ordersRepository.GetOrderingUser(username);
//check if payment ammount matches shopping cart total amount
decimal ammount = (decimal)paymentInfo.Amount / 100;
if (!_ordersRepository.PaymentEqualsShoppingCartSum(user, ammount))
{
return(BadRequest("Payment ammount does not match the shopping cart total ammount"));
}
//Get current user items in the shopping cart
var items = _ordersRepository.GetShoppingCartItems(user);
//make payment
//*****make payment*****
var httpWebRequest = (HttpWebRequest)WebRequest.Create("http://mock-payment-processor.appspot.com/v1/payment");
httpWebRequest.Credentials = new NetworkCredential("technologines", "platformos");
httpWebRequest.ContentType = "application/json";
httpWebRequest.Method = "POST";
using (var streamWriter = new StreamWriter(httpWebRequest.GetRequestStream()))
{
string json = Newtonsoft.Json.JsonConvert.SerializeObject(paymentInfo);
streamWriter.Write(json);
streamWriter.Flush();
streamWriter.Close();
}
try
{
var httpResponse = (HttpWebResponse)httpWebRequest.GetResponse();
PaymentResponse paymentResponseInfo = new PaymentResponse();
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
var paymentResponseJson = JObject.Parse(result);
paymentResponseInfo.Created_At = (DateTime)paymentResponseJson["created_at"];
paymentResponseInfo.Id = (string)paymentResponseJson["id"];
}
//*****payment made******
//create new order with those items list
Order newOrder = new Order
{
Cost = ammount,
Date = DateTime.Now,
UserId = user.Id,
OrderedItem = items,
PaymentId = paymentResponseInfo.Id,
PaymentDate = DateTime.Now
};
//save order to the database
newOrder = _ordersRepository.Add(newOrder);
//add new orders id to the ordered items
foreach (var orderedItem in items)
{
orderedItem.OrderId = newOrder.Id;
}
//clear shopping cart
_ordersRepository.ClearUserShoppingCart(user);
if (newOrder.PaymentId != null)
{
_ordersRepository.ClearUserShoppingCart(user);
return(Ok("Purchase successful"));
}
}
catch (Exception ex)
{
return(BadRequest("Payment went wrong"));
}
return(BadRequest("Payment went wrong"));
}
