public async Task <ActionResult> OnPost()
{
var category = new Domain.Entities.Category
{
CategoryName = CategoryVM.CategoryName,
Description = CategoryVM.Description,
};
if (!ModelState.IsValid)
{
return(Page());
}
using (var memoryStream = new MemoryStream())
{
await CategoryVM.Picture.CopyToAsync(memoryStream);
category.Picture = memoryStream.ToArray();
}
_repositoryWrapper.Category.Add(category);
_repositoryWrapper.Category.Save();
return(RedirectToPage("Card"));
}
protected async Task AddCategory(LibraryDbContext context, Guid id, string name)
{
var category = new Domain.Entities.Category(name)
{
Id = id, Status = Status.Added
};
context.Categories.Add(category);
await context.SaveChangesAsync();
}
public async Task Create(CategoryDto dto)
{
var category = new Domain.Entities.Category
{
Name = dto.Name,
ErasedState = false
};
await _categoryRepository.Create(category);
}
public async Task CreateCategoryCommand_ShouldSaveRequireNoteCorretly()
{
// Arrange
// Act
await new CreateCategoryCommand.Handler(contextAdapterMock.Object, backupServiceMock.Object, settingsFacadeMock.Object)
.Handle(new CreateCategoryCommand("Test", requireNote: true), default);
Domain.Entities.Category loadedCategory = context.Categories.First();
// Assert
loadedCategory.RequireNote.Should().BeTrue();
}
public async Task <Guid> Handle(CreateCategoryCommand request, CancellationToken cancellationToken)
{
var category = new Domain.Entities.Category
{
Id = Guid.NewGuid(),
Name = request.Name
};
await dataContext.Categories.InsertOneAsync(category);
return(category.Id);
}
public IActionResult RemoveCategory(Guid id)
{
if (getByIdCategoryUseCase.GetById(id) == null)
{
return(BadRequest());
}
var category = new Domain.Entities.Category(id);
removeCategoryUseCase.Remove(category);
return(new OkObjectResult(category));
}
public async Task <GetCategoryModel> Handle(CreateCategoryCommand request, CancellationToken cancellationToken)
{
var category = new Domain.Entities.Category(request.Name);
SetDomainState(category);
await _context.SaveChangesAsync(cancellationToken);
return(new GetCategoryModel
{
Id = category.Id,
Name = category.Name
});
}
/*[Authorize("Bearer")]*/
public IActionResult CreateCategory(string name)
{
var category = new Domain.Entities.Category(name);
var validationResult = new CategoryValidator().Validate(category);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
addCategoryUseCase.Add(category);
return(new OkObjectResult(category));
}
public ActionResult Edit(Domain.Entities.Category dto)
{
dto.ModifiedBy = Guid.Parse(User.Identity.GetUserId());
dto.ModifiedDate = DateTime.Now;
var response = _service.Save(dto);
if (response.IsSuccessful)
{
ViewBag.Success = true;
}
else
{
ViewBag.Success = false;
}
return(View());
}
public ActionResult Create(Domain.Entities.Category dto)
{
dto.CreatedBy = User.Identity.GetUserId();
dto.Id = Guid.NewGuid();
var response = _service.Save(dto);
if (response.IsSuccessful)
{
ViewBag.Success = true;
}
else
{
ViewBag.Success = false;
}
return(View());
}
public IActionResult UpdateCategory(Guid id, string name)
{
if (getByIdCategoryUseCase.GetById(id) == null)
{
return(BadRequest());
}
var category = new Domain.Entities.Category(id, name);
var validationResult = new CategoryValidator().Validate(category);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
updateCategoryUseCase.Update(category);
return(new OkObjectResult(category));
}
public async Task <Unit> Handle(CreateCategoryCommand request, CancellationToken cancellationToken)
{
var vResult = await new CreateCategoryCommandValidator(_context).ValidateAsync(request, cancellationToken);
if (!vResult.IsValid)
{
throw new ValidationException(vResult.Errors);
}
var entityCategory = new Domain.Entities.Category
{
Title = request.Title
};
_context.Categories.Add(entityCategory);
await _context.SaveChangesAsync(cancellationToken);
return(await Unit.Task);
}
public int Update(Domain.Entities.Category entity)
{
return(categoryWriteOnlyUseCase.Update(entity));
}
public static CategoryDetailModel Create(Domain.Entities.Category category)
{
return(Projection.Compile().Invoke(category));
}
private static async Task SaveGoodAsync(ApplicationContext context, MouserPart resultPart, Domain.Entities.Manufacturer manufacturer)
{
Domain.Entities.Category category = await context.Categories.FirstOrDefaultAsync(c => c.Name == resultPart.Category && c.Manufacturer.Id == manufacturer.Id);
if (category == null)
{
category = new Domain.Entities.Category
{
Manufacturer = manufacturer,
Name = resultPart.Category
};
context.Categories.Add(category);
await context.SaveChangesAsync();
}
Domain.Entities.Good good = await context.Goods
.FirstOrDefaultAsync(g => g.Manufacturer.Id == manufacturer.Id &&
g.Category.Id == category.Id &&
g.ManufacturerPartNumber == resultPart.ManufacturerPartNumber &&
g.MouserPartNumber == resultPart.MouserPartNumber);
Int32 min = 0;
Int32 mult = 0;
//Обновляем
if (good != null)
{
good.Description = resultPart.Description;
good.DataSheetUrl = resultPart.DataSheetUrl;
good.ImagePath = resultPart.ImagePath;
good.Min = Int32.TryParse(resultPart.Min, out min) ? min : 0;
good.Mult = Int32.TryParse(resultPart.Mult, out mult) ? mult : 0;
good.ProductDetailUrl = resultPart.ProductDetailUrl;
good.Reeling = resultPart.Reeling;
good.ROHSStatus = resultPart.ROHSStatus;
good.SuggestedReplacement = resultPart.SuggestedReplacement;
good.MultiSimBlue = resultPart.MultiSimBlue;
//Удаляем связанные справочники
IEnumerable <Domain.Entities.PriceBreak> pBForDelete = context.PriceBreaks.Where(p => p.Good.Id == good.Id).ToList();
context.PriceBreaks.RemoveRange(pBForDelete);
IEnumerable <Domain.Entities.AlternatePackaging> aPForDelete = context.AlternatePackagings.Where(p => p.Good.Id == good.Id).ToList();
context.AlternatePackagings.RemoveRange(aPForDelete);
IEnumerable <Domain.Entities.ProductAttribute> pAForDelete = context.ProductAttributes.Where(p => p.Good.Id == good.Id).ToList();
context.ProductAttributes.RemoveRange(pAForDelete);
IEnumerable <Domain.Entities.ProductCompliance> pCForDelete = context.ProductCompliances.Where(p => p.Good.Id == good.Id).ToList();
context.ProductCompliances.RemoveRange(pCForDelete);
//await context.SaveChangesAsync();
}
//Добавляем
else
{
good = new Domain.Entities.Good
{
Description = resultPart.Description,
DataSheetUrl = resultPart.DataSheetUrl,
ImagePath = resultPart.ImagePath,
Manufacturer = manufacturer,
ManufacturerPartNumber = resultPart.ManufacturerPartNumber,
Category = category,
Min = Int32.TryParse(resultPart.Min, out min) ? min : 0,
Mult = Int32.TryParse(resultPart.Mult, out mult) ? mult : 0,
MouserPartNumber = resultPart.MouserPartNumber,
ProductDetailUrl = resultPart.ProductDetailUrl,
Reeling = resultPart.Reeling,
ROHSStatus = resultPart.ROHSStatus
};
context.Goods.Add(good);
}
await context.SaveChangesAsync();
if (resultPart.PriceBreaks != null)
{
foreach (var priceBreak in resultPart.PriceBreaks.ToList())
{
context.PriceBreaks.Add(new Domain.Entities.PriceBreak
{
Good = good,
Currency = priceBreak.Currency,
Price = priceBreak.Price,
Quantity = priceBreak.Quantity
});
}
}
if (resultPart.AlternatePackagings != null)
{
foreach (var alternatePackaging in resultPart.AlternatePackagings.ToList())
{
context.AlternatePackagings.Add(new Domain.Entities.AlternatePackaging
{
Good = good,
APMfrPN = alternatePackaging.APMfrPN
});
}
}
if (resultPart.ProductAttributes != null)
{
foreach (var productAttribute in resultPart.ProductAttributes.ToList())
{
context.ProductAttributes.Add(new Domain.Entities.ProductAttribute
{
Good = good,
AttributeName = productAttribute.AttributeName,
AttributeValue = productAttribute.AttributeValue
});
}
}
if (resultPart.ProductCompliance != null)
{
foreach (var productCompliance in resultPart.ProductCompliance.ToList())
{
context.ProductCompliances.Add(new Domain.Entities.ProductCompliance
{
Good = good,
ComplianceName = productCompliance.ComplianceName,
ComplianceValue = productCompliance.ComplianceValue
});
}
}
await context.SaveChangesAsync();
}
public int Add(Domain.Entities.Category entity)
{
return(categoryWriteOnlyUseCase.Add(entity));
}