public async Task <int> Create(ProductCreateRequest request)
{
var status = 0;
var product = new Product {
Name = request.Name,
Price = request.Price,
PromotionPrice = request.PromotionPrice,
Description = request.Description,
Detail = request.Detail
};
if (request.ThumbnailImage != null)
{
product.ProductImages = new List <ProductImage>()
{
new ProductImage
{
Caption = "thumbnail image",
FileSize = request.ThumbnailImage.Length,
ImagePath = await this.SaveFile(request.ThumbnailImage)
}
};
}
var res = _context.Products.Add(product);
if (res != null)
{
status = await _context.SaveChangesAsync();
}
return(product.ID);
}
public async Task <IActionResult> PutAdmin(Guid id, Admin admin)
{
if (id != admin.AdminID)
{
return(BadRequest());
}
_context.Entry(admin).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AdminExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCartProduct(Guid id, CartProduct cartProduct)
{
if (id != cartProduct.CartProductID)
{
return(BadRequest());
}
_context.Entry(cartProduct).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CartProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutOrderCancel(Guid id, OrderCancel orderCancel)
{
if (id != orderCancel.OrderCancelID)
{
return(BadRequest());
}
_context.Entry(orderCancel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OrderCancelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCustomer(Guid id, Customer customer)
{
if (id != customer.CustomerID)
{
return(BadRequest());
}
_context.Entry(customer).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CustomerExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
/// <summary>
/// Create New record of Unit
/// </summary>
/// <param name="unit">Unit object</param>
/// <returns>bool:true/false</returns>
public async Task <bool> CreateUnitAsync(Unit unit)
{
await _context.Units.AddAsync(unit);
var created = await _context.SaveChangesAsync();
return(created > 0);
}
/// <summary>
/// Create New record of Category
/// </summary>
/// <param name="category">Category object</param>
/// <returns>bool:true/false</returns>
public async Task <bool> CreateCategoryAsync(Category category)
{
await _context.Categories.AddAsync(category);
var created = await _context.SaveChangesAsync();
return(created > 0);
}
/// <summary>
/// Create New record of Product
/// </summary>
/// <param name="Product">Product object</param>
/// <returns>bool:true/false</returns>
public async Task <bool> CreateProductAsync(Product product)
{
await _context.Products.AddAsync(product);
var created = await _context.SaveChangesAsync();
return(created > 0);
}
public async Task <Guid> AddAsync(T entity)
{
ArgumentGuard.NotNull(entity, nameof(entity));
await _dbContext.Set <T>().AddAsync(entity);
await _dbContext.SaveChangesAsync();
return(entity.Id);
}
public async Task <IActionResult> Create([Bind("Id,CategoryName")] Category category)
{
if (ModelState.IsValid)
{
_context.Add(category);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(category));
}
public async Task <IActionResult> Create([Bind("CartProductID,CartId,ProductID,ProductQuantityOrdered,ProductPrice,AddressId,TotalAmount,LastModifiedDateTime")] CartProduct cartProduct)
{
if (ModelState.IsValid)
{
cartProduct.CartProductID = Guid.NewGuid();
_context.Add(cartProduct);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cartProduct));
}
public async Task <IActionResult> Create([Bind("OrderDetailId,OrderId,IsCancelled,ProductID,ProductQuantityOrdered,ProductPrice,AddressId,TotalAmount,LastModifiedDateTime,DateOfOrder,OrderSerial")] OrderDetail orderDetail)
{
if (ModelState.IsValid)
{
orderDetail.OrderDetailId = Guid.NewGuid();
_context.Add(orderDetail);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(orderDetail));
}
public async Task <IActionResult> Create([Bind("OrderId,CustomerID,DateOfOrder,TotalQuantity,LastModifiedDateTime,OrderAmount,OrderNumber")] Order order)
{
if (ModelState.IsValid)
{
order.OrderId = Guid.NewGuid();
_context.Add(order);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(order));
}
public async Task <IActionResult> Create([Bind("AddressID,AddressLine1,AddressLine2,Landmark,City,State,PinCode,CustomerID,CreationDateTime,LastModifiedDateTime")] Address address)
{
if (ModelState.IsValid)
{
address.AddressID = Guid.NewGuid();
_context.Add(address);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(address));
}
public async Task <IActionResult> Create([Bind("CustomerID,CustomerName,Email,Password,CustomerMobile,CreationDateTime,LastModifiedDateTime")] Customer customer)
{
if (ModelState.IsValid)
{
customer.CustomerID = Guid.NewGuid();
_context.Add(customer);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(customer));
}
public async Task <IActionResult> Create([Bind("OrderCancelID,CartProductID,QuantityToBeCancelled,RefundAmount")] OrderCancel orderCancel)
{
if (ModelState.IsValid)
{
orderCancel.OrderCancelID = Guid.NewGuid();
_context.Add(orderCancel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(orderCancel));
}
public async Task <IActionResult> Create([Bind("AdminID,AdminName,Email,Password,CreationDateTime,LastModifiedDateTime")] Admin admin)
{
if (ModelState.IsValid)
{
admin.AdminID = Guid.NewGuid();
_context.Add(admin);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(admin));
}
public async Task <IActionResult> Create([Bind("CartId,AddressID,CustomerID,TotalQuantity,TotalAmount")] Cart cart)
{
if (ModelState.IsValid)
{
cart.CartId = Guid.NewGuid();
_context.Add(cart);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(cart));
}
public async Task <IActionResult> Create([Bind("ProductID,ProductName,ProductColor,ProductSize,ProductMaterial,Category,ProductPrice,CreationDateTime,LastModifiedDateTime")] Product product)
{
if (ModelState.IsValid)
{
product.ProductID = Guid.NewGuid();
_context.Add(product);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(product));
}
/// <summary>
/// Create New record of Order
/// </summary>
/// <param name="Order">Order object</param>
/// <returns>bool:true/false</returns>
public async Task <bool> CreateOrderAsync(Order order)
{
await _context.Orders.AddAsync(order);
var created = await _context.SaveChangesAsync();
var ItemsClearToCart = await _context.ShoppingCarts.Where(x => x.CreatedBy == order.CreatedBy).ToListAsync();
_context.ShoppingCarts.RemoveRange(ItemsClearToCart);
await _context.SaveChangesAsync();
///await AddNewOrderDetail(order);
return(created > 0);
}
public async Task <ProductEntity> CreateProductAsync(ProductServiceModel serviceModel, bool save = true)
{
var newProduct = serviceModel.Product;
newProduct.CreateByUserId = serviceModel.User.Id;
var entry = _context.ProductEntity.Add(newProduct);
if (save == true)
{
await _context.SaveChangesAsync();
}
return(entry.Entity);
}
public async Task <IActionResult> Create([Bind("Id,ProductName,ProductDescription,ProductImageUrl")] Product product, IFormFile productImage)
{
if (ModelState.IsValid)
{
string url = await fileService.Create(productImage);
product.ProductImageUrl = url;
_context.Add(product);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(product));
}
public async Task SeedData()
{
await _dbContext.Database.EnsureCreatedAsync();
if (!_dbContext.AppUsers.Any())
{
SeedUser();
await _dbContext.SaveChangesAsync();
}
if (!_dbContext.Products.Any())
{
SeedProducts();
await _dbContext.SaveChangesAsync();
}
}
/// <summary>
///
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public async Task <bool> AddItemInCart(ShoppingCart item)
{
var existItem = await _context.ShoppingCarts.FirstOrDefaultAsync(x => x.ProductId == item.ProductId && x.CreatedBy == item.CreatedBy);
if (existItem != null)
{
existItem.Quantity = existItem.Quantity + item.Quantity;
_context.ShoppingCarts.Update(existItem);
var updated = await _context.SaveChangesAsync();
return(updated > 0);
}
else
{
await _context.ShoppingCarts.AddAsync(item);
var created = await _context.SaveChangesAsync();
return(created > 0);
}
}
public virtual async Task <T> AddAsync(T entity, bool isSaved = true)
{
await DbContext.Set <T>().AddAsync(entity);
if (isSaved)
{
await DbContext.SaveChangesAsync();
}
return(entity);
}
public async Task <int> SaveAsync(CancellationToken cancellationToken = default(CancellationToken))
{
int result;
try
{
result = await _context.SaveChangesAsync(cancellationToken);
}
catch (Exception ex)
{
throw new Exception(ex.Message, ex.InnerException);
}
return(result);
}
/// <summary>
/// Refresh user authentication token
/// </summary>
/// <param name="token">Token</param>
/// <param name="refreshToken">Refresh Token</param>
/// <returns></returns>
public async Task <AuthenticationResult> RefreshTokenAsync(string token, string refreshToken)
{
var validatedToken = GetPrincipalFromToken(token);
if (validatedToken == null)
{
return(new AuthenticationResult {
Errors = new[] { "Invalid Token" }
});
}
var expiryDateUnix =
long.Parse(validatedToken.Claims.Single(x => x.Type == JwtRegisteredClaimNames.Exp).Value);
var expiryDateTimeUtc = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc)
.AddSeconds(expiryDateUnix);
if (expiryDateTimeUtc > DateTime.UtcNow)
{
return(new AuthenticationResult {
Errors = new[] { "This token hasn't expired yet" }
});
}
var jti = validatedToken.Claims.Single(x => x.Type == JwtRegisteredClaimNames.Jti).Value;
var storedRefreshToken = await _context.RefreshTokens.SingleOrDefaultAsync(x => x.Token == refreshToken);
if (storedRefreshToken == null)
{
return(new AuthenticationResult {
Errors = new[] { "This refresh token does not exist" }
});
}
if (DateTime.UtcNow > storedRefreshToken.ExpiryDate)
{
return(new AuthenticationResult {
Errors = new[] { "This refresh token has expired" }
});
}
if (storedRefreshToken.Invalidated)
{
return(new AuthenticationResult {
Errors = new[] { "This refresh token has been invalidated" }
});
}
if (storedRefreshToken.Used)
{
return(new AuthenticationResult {
Errors = new[] { "This refresh token has been used" }
});
}
if (storedRefreshToken.JwtId != jti)
{
return(new AuthenticationResult {
Errors = new[] { "This refresh token does not match this JWT" }
});
}
storedRefreshToken.Used = true;
_context.RefreshTokens.Update(storedRefreshToken);
await _context.SaveChangesAsync();
var user = await _userManager.FindByIdAsync(validatedToken.Claims.Single(x => x.Type == "id").Value);
return(await GenerateAuthenticationResultForUserAsync(user));
}
