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)); }