public async Task <Product> Save(Product aggregate)
{
var product = _dbContext.Products.Add(aggregate);
await _dbContext.SaveChangesAsync();
return(product.Entity);
}
public async Task <IActionResult> PutProduct(int id, Product product)
{
if (id != product.Id)
{
return(BadRequest());
}
_context.Entry(product).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutGenre(int id, Genre genre)
{
if (id != genre.GenreID)
{
return(BadRequest());
}
_context.Entry(genre).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!GenreExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutBook(int id, Book book)
{
if (id != book.BookID)
{
return(BadRequest());
}
_context.Entry(book).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BookExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <CatalogExport> Save(CatalogExport aggregate)
{
var product = _dbContext.CatalogExports.Add(aggregate);
await _dbContext.SaveChangesAsync();
return(product.Entity);
}
public async Task <IActionResult> PutColor(int id, Color color)
{
if (id != color.Id)
{
return(BadRequest());
}
_context.Entry(color).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ColorExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> CreateBookAsync([FromBody] BookInputViewModel bookToCreate)
{
var book = _catalogContext.Books.Add(new Book());
book.CurrentValues.SetValues(bookToCreate);
book.Entity.BooksAuthors.AddRange(MapBookAuthorsToBookAuthorEnumerable(book.Entity, bookToCreate));
await _catalogContext.SaveChangesAsync();
return(CreatedAtAction(nameof(GetBookById), new { id = book.Entity.Id }, null));
List <BookAuthor> MapBookAuthorsToBookAuthorEnumerable(Book book, BookInputViewModel bookVm)
{
var bookAuthors = new List <BookAuthor>();
foreach (var id in bookVm.AuthorsIds)
{
bookAuthors.Add(new BookAuthor
{
AuthorId = id,
Book = book
});
}
return(bookAuthors);
}
}
public async Task <IActionResult> PutSubCategory(int id, SubCategory subCategory)
{
if (id != subCategory.Id)
{
return(BadRequest());
}
_context.Entry(subCategory).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!SubCategoryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <TEntity> AddAsync(TEntity entity)
{
await _context.Set <TEntity>().AddAsync(entity);
await _context.SaveChangesAsync();
return(entity);
}
public async Task <ActionResult <AuthorOutputViewModel> > CreateAuthorAsync([FromBody] AuthorInputViewModel authorToCreate)
{
var a = _catalogContext.Authors.Add(new Author());
a.CurrentValues.SetValues(authorToCreate);
await _catalogContext.SaveChangesAsync();
return(CreatedAtAction(nameof(GetAuthorById), new { id = a.Entity.Id }, MapAuthorToAuthorOutputViewModel(a.Entity)));
}
public async Task <ActionResult> Create(TrainingProviderViewModels.CreateViewModel createModel)
{
var validImageTypes = new[]
{
"image/gif",
"image/jpeg",
"image/pjpeg",
"image/png"
};
var logoUpload = createModel.LogoUpload;
if (logoUpload == null || logoUpload.ContentLength == 0)
{
ModelState.AddModelError("LogoUpload", "Logo file is required.");
}
else if (!validImageTypes.Contains(logoUpload.ContentType))
{
ModelState.AddModelError("LogoUpload", "Please choose either a GIF, JPG or PNG image.");
}
if (ModelState.IsValid)
{
try
{
var logoSavePath = Path.Combine(Server.MapPath(AppConstants.VirtualPaths.TrainingProvidersContent), createModel.LogoUpload.FileName);
createModel.LogoUpload.SaveAs(logoSavePath);
_db.TrainingProviders.Add(new TrainingProvider
{
Name = createModel.Name,
Description = createModel.Description,
SiteUrl = createModel.SiteUrl,
LogoFileName = createModel.LogoUpload.FileName,
UpdateFrequencyHours = createModel.UpdateFrequencyHours,
AllowedUpdateUtcHours = createModel.SelectedUpdateHours,
SourceUrl = createModel.SourceUrl,
SourceLocation = createModel.SourceLocation,
AssemblyType = createModel.AssemblyType,
IsDeleted = createModel.IsDeleted
});
await _db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(createModel));
}
}
return(View(createModel));
}
public async Task A_Product_Can_Be_Found_By_Id_Async()
{
_catalogDbContext.Add(new Product()
{
Id = 1, Sku = "ABC-123", BrandId = 1, SupplierId = 1
});
await _catalogDbContext.SaveChangesAsync();
var result = await _productService.GetAsync(1);
Assert.That(result, Is.Not.Null);
Assert.That(result.Id, Is.EqualTo(1));
}
public bool Add(Tenants tenant)
{
_catalogDbContext.Tenants.Add(tenant);
_catalogDbContext.SaveChangesAsync();
return(true);
}
public async Task AddAndSaveEventAsync(IntegrationEvent @event)
{
await ResilientTransaction.CreateNew(catalogDbContext).ExecuteAsync(async() => {
await catalogDbContext.SaveChangesAsync();
await eventLogService.SaveEventAsync(@event, catalogDbContext.Database.CurrentTransaction);
});
}
public async Task Getting_All_Brands_Returns_First_Page_Only()
{
var brands = GetBrandsForPaging();
foreach (var brand in brands)
{
await _catalogDbContext.Brands.AddAsync(brand);
}
await _catalogDbContext.SaveChangesAsync();
var result = await _brandService.GetAllAsync(5, 0);
Assert.That(result.Count, Is.EqualTo(5));
Assert.That(result.First().Id, Is.EqualTo(1));
Assert.That(result.Last().Id, Is.EqualTo(5));
}
public async Task Getting_All_Suppliers_Returns_First_Page_Only()
{
var suppliers = GetSuppliersForPaging();
foreach (var supplier in suppliers)
{
await _catalogDbContext.Suppliers.AddAsync(supplier);
}
await _catalogDbContext.SaveChangesAsync();
var result = await _supplierService.GetAllAsync(5, 0);
Assert.That(result.Count, Is.EqualTo(5));
Assert.That(result.First().Id, Is.EqualTo(1));
Assert.That(result.Last().Id, Is.EqualTo(5));
}
public async Task <bool> DeleteProduct(int id, [Service] CatalogDbContext dbContext)
{
var product = await dbContext.Products.FindAsync(id);
dbContext.Remove(product);
await dbContext.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> UpdateProduct([FromBody] CatalogItem productToUpdate)
{
var catalogItem = await _catalogContext.CatalogItems.SingleOrDefaultAsync(i => i.Id == productToUpdate.Id);
if (catalogItem == null)
{
return(NotFound(new { Message = $"Item with id {productToUpdate.Id} not found." }));
}
var oldPrice = catalogItem.Price;
var raiseProductPriceChangedEvent = oldPrice != productToUpdate.Price;
catalogItem = productToUpdate;
_catalogContext.CatalogItems.Update(catalogItem);
await _catalogContext.SaveChangesAsync();
return(CreatedAtAction(nameof(GetItemById), new { id = productToUpdate.Id }, null));
}
public async Task SaveEventAndCatalogContextChangesAsync(IntegrationEvent evt)
{
//Use of an EF Core resiliency strategy when using multiple DbContexts within an explicit BeginTransaction():
//See: https://docs.microsoft.com/en-us/ef/core/miscellaneous/connection-resiliency
await ResilientTransaction.New(_catalogContext)
.ExecuteAsync(async() => {
// Achieving atomicity between original catalog database operation and the IntegrationEventLog thanks to a local transaction
await _catalogContext.SaveChangesAsync();
await _eventLogService.SaveEventAsync(evt, _catalogContext.Database.CurrentTransaction);
});
}
public async Task Handle(ProductCreateCommand command, CancellationToken cancellationToken)
{
await context.AddAsync(new Product
{
Name = command.Name,
Description = command.Description,
Price = command.Price
});
await context.SaveChangesAsync();
}
public async Task SeedAsync(CatalogDbContext context, IHostingEnvironment env, IOptions <CatalogSettings> settings, ILogger <CatalogContextSeed> logger)
{
var policy = CreatePolicy(logger, nameof(CatalogContextSeed));
await policy.ExecuteAsync(async() =>
{
var useCustomizationData = settings.Value.UseCustomizationData;
var contentRootPath = env.ContentRootPath;
var picturePath = env.WebRootPath;
if (!context.CatalogBrands.Any())
{
await context.CatalogBrands.AddRangeAsync(useCustomizationData
? GetCatalogBrandsFromFile(contentRootPath, logger)
: GetPreconfiguredCatalogBrands());
await context.SaveChangesAsync();
}
if (!context.CatalogTypes.Any())
{
await context.CatalogTypes.AddRangeAsync(useCustomizationData
? GetCatalogTypesFromFile(contentRootPath, logger)
: GetPreconfiguredCatalogTypes());
await context.SaveChangesAsync();
}
if (!context.CatalogItems.Any())
{
await context.CatalogItems.AddRangeAsync(useCustomizationData
? GetCatalogItemsFromFile(contentRootPath, context, logger)
: GetPreconfiguredItems());
await context.SaveChangesAsync();
GetCatalogItemPictures(contentRootPath, picturePath);
}
});
}
public Task Save(Product product, CancellationToken cancellationToken)
{
if (product.Id == default(int))
{
_db.Products.AddAsync(product, cancellationToken);
}
else
{
_db.Entry(product).State = EntityState.Modified;
}
return(_db.SaveChangesAsync(cancellationToken));
}
public async Task <Product> UpdateProduct(int id, UpdateProductDto input, [Service] CatalogDbContext dbContext)
{
var product = await dbContext.Products.FindAsync(id);
product.Name = input.Name;
product.Price = input.Price;
product.Quantity = input.Quantity;
product.CategoryId = input.CategoryId;
product.Discontinued = input.Discontinued;
await dbContext.SaveChangesAsync();
return(product);
}
public async Task <IActionResult> Add([FromBody] Product catalogItem)
{
// TODO - Extraer el saveContext a un repository para aplicar el repository pattern.
var catalogItemAdded = catalogContext.Add(catalogItem);
await catalogContext.SaveChangesAsync();
var productAddedEvent = new ProductAddedIntegrationEvent(catalogItem);
await catalogIntegrationEventService.AddAndSaveEventAsync(productAddedEvent);
await catalogIntegrationEventService.PublishEventsThroughEventBusAsync(productAddedEvent);
return(Ok(catalogItemAdded.Entity.Id));
//return CreatedAtAction(nameof(GetCatalogItem), new { id = catalogItemAdded.Entity.Id });
}
public async Task <Product> CreateProduct(CreateProductDto input, [Service] CatalogDbContext dbContext)
{
var product = new Product
{
Name = input.Name,
Price = input.Price,
CategoryId = input.CategoryId
};
dbContext.Products.Add(product);
await dbContext.SaveChangesAsync();
return(product);
}
public async Task Handle(OrderStatusChangedToPaidIntegrationEvent @event)
{
//we're not blocking stock/inventory
foreach (var orderStockItem in @event.OrderStockItems)
{
var catalogItem = _context.CatalogItems.Find(orderStockItem.ProductId);
if (catalogItem != null)
{
catalogItem.RemoveStock(orderStockItem.Units);
}
}
await _context.SaveChangesAsync();
}
public async Task <ActionResult> PostProduct([FromBody] Product product)
{
if (ModelState.IsValid)
{
_db.Products.Add(product);
await _db.SaveChangesAsync();
return(Created("", product));
}
else
{
}
return(null);
}
public async Task Handle(ProductInStockUpdateStockCommand notification, CancellationToken cancellationToken)
{
logger.LogInformation("---ProductInStockUpdateStockCommand stared");
var products = notification.Items.Select(x => x.ProductId);
var stocks = await dbContext.Stocks.Where(x => products.Contains(x.ProductInStockId)).ToListAsync();
logger.LogInformation("---Retrieved products from database");
foreach (var item in notification.Items)
{
var entry = stocks.SingleOrDefault(x => x.ProductInStockId == item.ProductId);
switch (item.Action)
{
case Common.Enums.ProductInStockAction.Add:
if (entry == null)
{
entry = new ProductInStock()
{
ProductId = item.ProductId
};
await dbContext.AddAsync(entry);
logger.LogInformation($"--- New stock record was created for {entry.ProductId} because didn't exists before");
}
entry.Stock += item.Stock;
logger.LogInformation($"---Product {entry.ProductId} - its stock was increased and its new stock is {entry.Stock}");
break;
case Common.Enums.ProductInStockAction.Substract:
if (entry == null || item.Stock > entry.Stock)
{
logger.LogError($"---Product {entry.ProductId} - doesn't have enough stock");
throw new Exception($"Product {entry.ProductId} - doesn't have enough stock");
}
logger.LogInformation($"---Product {entry.ProductId} - its stock was subtracted and its new stock is {entry.Stock}");
entry.Stock -= item.Stock;
break;
}
await dbContext.SaveChangesAsync();
logger.LogInformation("---ProductInStockUpdateStockCommand ended");
}
}
public async Task Handle(ProductInStockUpdateStockCommand notification, CancellationToken cancellationToken)
{
_logger.LogInformation("--- ProductInStockUpdateStockCommand started");
var products = notification.Items.Select(x => x.ProductId);
var stocks = await context.Stocks.Where(x => products.Contains(x.ProductId)).ToListAsync();
_logger.LogInformation("--- Retrieve products from database");
foreach (var item in notification.Items)
{
var entry = stocks.SingleOrDefault(x => x.ProductId == item.ProductId);
if (item.Action == ProductInStockAction.Substract)
{
if (entry == null || item.Stock > entry.Stock)
{
_logger.LogError($"--- Product {entry.ProductId} -doens't have enough stock");
throw new ProductInStockUpdateStockCommandException($"Product {entry.ProductId} - doens't have enough stock");
}
entry.Stock -= item.Stock;
_logger.LogInformation($"--- Product {entry.ProductId} - its stock was subtracted and its new stock is {entry.Stock}");
}
else
{
if (entry == null)
{
entry = new ProductInStock
{
ProductId = item.ProductId
};
_logger.LogInformation($"--- New stock record was created for {entry.ProductId} because didn't exists before");
await context.AddAsync(entry);
}
_logger.LogInformation($"--- Add stock to product {entry.ProductId}");
entry.Stock += item.Stock;
}
}
await context.SaveChangesAsync();
}
public async Task <ActionResult> CategoryCourses(int?categoryId, ControllableViewModelParams modelParams,
IEnumerable <CoursesWithoutSpecializationsViewModels.SelectedSpecializationsModel> selectedSpecializations)
{
if (categoryId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (ModelState.IsValid)
{
do
{
var courseSpecializations = selectedSpecializations
.Where(x => x.Specializations != null && x.Specializations.Any())
.SelectMany(x => x.GetCourseSpecializations());
_db.CourseSpecializations.AddRange(courseSpecializations);
try
{
await _db.SaveChangesAsync();
}
// ReSharper disable once CatchAllClause
catch (Exception ex)
{
ModelState.AddModelError("", ex.ToString());
break;
}
return(RedirectToAction("Index", modelParams));
// only for flow control
#pragma warning disable 162
} while (false);
#pragma warning restore 162
}
var viewModel = await GetCategoryCoursesViewModel(categoryId.Value);
if (viewModel != null)
{
ViewData.SetControllableViewModelParams(modelParams);
}
return(View(viewModel));
}
