public void ImportWarehouse(Warehouse warehouse)
{
logger.LogDebug($"Validating warehouse {warehouse.Code}");
WarehouseValidator validator = new WarehouseValidator();
ValidationResult result = validator.Validate(warehouse);
Console.WriteLine(warehouse.Code);
Console.WriteLine(warehouse.Description);
if (result.IsValid)
{
Data.Warehouse dataWarehouse = this.mapper.Map <Data.Warehouse>(warehouse);
logger.LogDebug($"Importing warehouse {warehouse.Code} into repo");
try {
//TODO: delete before importing new hierarchy!!!
//delete Hierarchy
wareHouseRepository.Create(dataWarehouse);
}
catch (DataAccessLayerException e)
{
throw new BusinessLayerException("DAL Exception", e);
}
}
else
{
throw new InvalidWarehouseException(string.Join("\n", result.Errors));
}
}
public bool AddWarehouseRoot(WarehouseModel warehouse)
{
try
{
// bool isOK = true;
if (ValidateWarehouseModel(warehouse))
{
var mapped = Mapper.Map <WarehouseModel, WarehouseDTO>(warehouse);
_warehouseRepository.Create(mapped);
return(true);
/* foreach (WarehouseModel wh in warehouse.NextHops)
* {
* wh.Parent = warehouse;
* isOK = isOK && AddWarehouseRecursive(wh);
* }
*
* var warehouseDAO = Mapper.Map<WarehouseModel, WarehouseDAO>(warehouse);
* _warehouseRepository.Create(warehouseDAO);
* _logger.Info("WarehouseRoot added: " + warehouseDAO.Code);
* return isOK;*/
}
return(false);
}
catch (Exception ex)
{
throw new BLException("Error setting up warehouses", ex);
}
}
public async Task <EntityValidationResult <Warehouse> > AddWarehouse(Warehouse data)
{
try
{
var result = new EntityValidationResult <Warehouse>();
var validationResult = _validator.Validate(data);
result.IsValid = validationResult.IsValid;
result.Object = data;
if (validationResult.IsValid)
{
data.Id = Guid.NewGuid();
_warehouseRepository.Create(data);
await _warehouseRepository.SaveAsync();
}
else
{
result.Errors = validationResult.Errors.Select(x => new EntityValidationFailure {
PropertyName = x.PropertyName, ErrorMessage = x.ErrorMessage
}).ToList();
}
return(result);
}
catch (Exception ex)
{
throw ex;
}
}
public IActionResult Create(warehouse Warehouse)
{
if (!ModelState.IsValid)
{
return(View(Warehouse));
}
_repository.Create(Warehouse);
return(RedirectToAction("List"));
}
public CommandResult Create(ProductCreateCommand productCreate, List <WarehouseCreateCommand> warehouseCommandList)
{
if (productCreate.IsValid() == false)
{
return(CommandResult.Error(productCreate.ValidationResult.ToString()));
}
if (_productRepository.Exists(productCreate.Sku) == true)
{
return(CommandResult.Error("Sku do produto já existe."));
}
foreach (var item in warehouseCommandList)
{
if (item.IsValid() == false)
{
return(CommandResult.Error(item.ValidationResult.ToString()));
}
}
var product = new Product(sku: productCreate.Sku, name: productCreate.Name);
var warehouseList = warehouseCommandList
.Select(x => new Warehouse(
sku: product.Sku,
locality: x.Locality,
quantity: x.Quantity,
type: x.Type
));
_productRepository.Create(product);
foreach (var warehouse in warehouseList)
{
_warehouseRepository.Create(warehouse);
}
return(CommandResult.Ok());
}
public IActionResult Post([FromBody] Warehouse model)
{
if (ModelState.IsValid)
{
_repository.Create(model);
return(Ok(model));
}
else
{
return(new ResponseResult(Response)
{
StatusCode = (int)StatusCodes.Status400BadRequest, ResponseObject = ModelState.ToJson()
}.ToJsonResult());
}
}
public ActionResult <Warehouse> Post([FromBody] Warehouse warehouse)
{
try
{
warehouse.WarehouseID = Guid.NewGuid();
warehouseRepo.Create(warehouse);
return(CreatedAtRoute("GetWarehouseID",
new
{
id = warehouse.WarehouseID
},
warehouse));
}
catch (Exception)
{
return(BadRequest());
}
}
public void ImportWarehouses(IO.Swagger.Models.Warehouse warehouse)
{
try
{
var blWarehouse = _mapper.Map <Entities.Warehouse>(warehouse);
if (blWarehouse != null)
{
string validationResults = ValidateWarehouse(blWarehouse);
if (validationResults != "")
{
_logger.LogError(validationResults);
throw new BlException("Given Warehouse is not valid");
}
}
var dalWarehouse = _mapper.Map <DataAccess.Entities.Warehouse>(blWarehouse);
_dbCleaner.CleanDb();
_warehouseRepo.Create(dalWarehouse);
}
catch (Exception ex)
{
_logger.LogError("Cannot import warehouses", ex);
throw new BlException("Cannot import warehouses", ex);
}
}