public async Task Consume(ConsumeContext <StockRequest> context)
{
var stockCode = context.Message.StockCode;
var stockResponse = new StockResponse
{
Success = true,
ConnectionId = context.Message.ConnectionId,
StockCode = stockCode,
};
StockDto stock = null;
try
{
stock = await _stockService.GetStock(stockCode);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
stockResponse.Success = false;
}
stockResponse.Stock = stock;
//
await context.Publish(stockResponse);
_logger.LogInformation("Stock request recieved {0}", stockCode);
}
public async Task <ActionResult> CreateStocks(CreateStockDto input)
{
foreach (var items in input.Stocks)
{
var check = await _stockService.CheckIfExist(items.ProductId);
if (check != null)
{
check.TotalPieces += items.TotalPieces;
check.Amount += items.Amount;
await _stockService.UpdateAsync(check);
}
else
{
var stocks = new StockDto
{
ProductId = items.ProductId,
TotalPieces = items.TotalPieces,
PricePerPiece = items.PricePerPiece,
Amount = items.Amount
};
await _stockService.CreateAsync(stocks);
}
}
return(Ok(input.Stocks));
}
public async Task <IActionResult> UpdateStock(int pStockId, StockDto pStockDto)
{
try
{
var stock = await _repo.GetStockAsyncById(pStockId);
if (stock == null)
{
return(NotFound());
}
_mapper.Map(pStockDto, stock);
_repo.Update(stock);
var stockUpdated = _mapper.Map <StockDto>(stock);
if (await _repo.SaveChangesAsync())
{
return(Created($"/api/stock/id/{stock.Id}", stockUpdated));
}
}
catch (Exception e)
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Banco de Dados Falhou: " + e.Message));
}
return(BadRequest());
}
public async Task <ActionResult> CreatePurchaseOrder(CreatePurchaseOrderDto dto)
{
await _purchaseOderService.CreateAsync(dto);
foreach (var items in dto.PurchaseOrderDetails)
{
var check = await _stockService.CheckIfExist(items.ProductId);
if (check != null)
{
check.TotalPieces += items.TotalPieces;
check.Amount += items.Amount;
await _stockService.UpdateAsync(check);
}
else
{
var stocks = new StockDto
{
ProductId = items.ProductId,
TotalPieces = items.TotalPieces,
PricePerPiece = items.PricePerPiece,
Amount = items.Amount
};
await _stockService.CreateAsync(stocks);
}
}
return(Ok(dto));
}
public void TestSaveStock()
{
//Arrange
Mock <IStockRepository> mockStockRepository =
new Mock <IStockRepository>();
IList <ProductDto> products = new List <ProductDto>()
{
new ProductDto()
{
ProductName = "Product1",
Ingrediants = "ingrediants",
Descriptions = "Descriptions",
Quantity = 500
}
};
StockDto stock =
new StockDto()
{
TotalPrice = 5000,
TotalQuantity = 500,
Products = products
};
IStockApplicationService stocksApplicationService =
new StockApplicationService(mockStockRepository.Object);
//Act
Stock result = stocksApplicationService.SaveStock(stock);
//Assert
Assert.IsType <Stock>(result);
}
public async Task Delete(StockDto dto)
{
var stock = await _stockRepository.GetById(dto.Id);
if (stock != null)
{
var delete = await _stockRepository.GetById(stock.Id);
if (delete.ErasedState)
{
delete.ErasedState = false;
await _stockRepository.Update(delete);
}
else
{
delete.ErasedState = true;
await _stockRepository.Update(delete);
}
}
else
{
throw new Exception("This Stock not existe");
}
}
public async Task <IActionResult> Patch([FromBody] StockDto stockDto)
{
var validator = new UpdateStockDtoValidator();
var validationResult = await validator.ValidateAsync(stockDto);
if (!validationResult.IsValid)
{
return(BadRequest(validationResult.Errors));
}
try
{
await stockService.PatchStockAsync(stockDto);
return(Ok("Stock price updated"));
}
catch (NotFoundInDbException ntEx)
{
return(NotFound(ntEx.Message));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public void ParseInput(IEnumerable <string> inputs)
{
var items = _controller.GetItems();
var stocks = new List <StockDto>();
for (int i = 0; i < inputs.Count(); i++)
{
var input = inputs.ElementAt(i);
var sections = input.Split(',');
var name = sections[0].Trim();
var dto = new StockDto {
Id = i
};
if (items.Select(s => s.Name).Contains(name))
{
var daysTillOff = int.Parse(sections[1].Trim());
var currentQuality = int.Parse(sections[2].Trim());
dto.ItemId = items.First(s => s.Name == name).Id;
dto.SellByDates = _today.AddDays(daysTillOff);
dto.Quality = currentQuality;
}
stocks.Add(dto);
}
_controller.SetStocks(stocks);
}
public async Task <IActionResult> Update(StockDto stockDto)
{
var n = _mapper.Map <Stock>(stockDto);
await _stocksService.UpdateStockAsync(n);
return(Ok());
}
/// <summary>
/// 查询库存信息
/// </summary>
/// <param name="id">库存Id</param>
/// <returns></returns>
public StockDto GetStockInfo(int id)
{
var result = new StockDto();
try
{
using (var db = SugarDao.GetInstance())
{
var list = db.Queryable <Domain.Model.Stock>()
.JoinTable <Medicine>((s, m) => s.MedicineId == m.Id)
.JoinTable <Medicine, BasicDictionary>((s, m, sccj) => m.SCCJId == sccj.Id) //生产厂家
.JoinTable <Medicine, BasicDictionary>((s, m, ypdw) => m.UnitId == ypdw.Id) //药品单位
.JoinTable <Medicine, BasicDictionary>((s, m, gys) => m.SupplierId == gys.Id) //供应商
.JoinTable <Medicine, BasicDictionary>((s, m, jyfw) => m.JYFWId == jyfw.Id) //经营范围
.Where($" s.Id={id}")
.Select <StockDto>("s.Id,m.Name MedicineName,m.CommonName MedicineCommonName,m.NameCode,m.IsPrescription,s.Sale,m.BZGG YPGG,ypdw.Name YPDW,s.BatchNum,s.Amount,sccj.Name SCCJ,s.BeginDate,s.EndDate,gys.Name GysName,s.Cost,jyfw.Name JyfwName").ToList();
if (list != null && list.Any())
{
result = list[0];
}
}
}
catch (System.Exception)
{
throw;
}
return(result);
}
public IActionResult Post([FromBody] StockDto stock)
{
if (stock == null)
{
return(BadRequest(ModelState));
}
_stockApplicationService.SaveStock(stock);
return(Created("api/stock", stock));
}
public async Task Create(StockDto dto)
{
var stock = new Domain.Entities.Stock
{
Quantity = dto.Quantity,
ErasedState = false
};
await _stockRepository.Create(stock);
}
public async Task PatchStockAsync(StockDto stockDto)
{
Stock thisStock = await repository.GetOneAsync(stockDto.Code);
Stock newStock = thisStock with {
PreviousPrice = thisStock.Price, Price = stockDto.Price
};
await repository.UpdateAsync(newStock);
}
}
public async Task ActualizarStock(StockDto dto)
{
using (var context = new DataContext())
{
var stock = _mapper.Map <Dominio.Entidades.Stock>(dto);
await _stockRepositorio.Create(stock);
return;
}
}
public void StockServiceUpdate_UnitOfWorkUpdateAndComplete_ReturnsUnitOfWorkUpdateAndComplete()
{
var stockDto = new StockDto();
var entity = Mapper.Map <StockDto, Stock>(stockDto);
_stockService.Update(stockDto);
_uow.Received().Stocks.Update(entity);
_uow.Received().Complete();
}
private async Task <StockDto> ReportWrapper(Stock stock, DateTime date, int period, int lookback)
{
StockDto dto = stock.MapTo <StockDto>();
dto.StockReports = await GetReports(stock.Symbol, date, period, lookback);
this._consoleHubProxy.WriteLine(ConsoleWriteLineInput.Create($"Generating reports for : {stock.Symbol}"));
return(dto);
}
public void Start()
{
const string queryString = "SELECT [ID],[WKN],[Name],[Type],[IsDividend],[LongShort] FROM [dbo].[Stocks] ORDER BY [ID] ASC";
const string countString = "SELECT COUNT([ID]) AS COUNT FROM [dbo].[Stocks]";
const string connectionString = "Server=.;Database=TransactionManagement;User Id=stocktrading;Password=stocktrading;";
//Load from db
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var command = new SqlCommand(countString, connection))
{
var count = (int)command.ExecuteScalar();
LoggingService.Info($" ({count})");
}
using (var command = new SqlCommand(queryString, connection))
{
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
var item = new StockDto();
item.OldId = int.Parse(reader["ID"].ToString());
item.IsDividend = bool.Parse(reader["IsDividend"].ToString());
item.LongShort = reader["LongShort"].ToString();
item.Name = reader["Name"].ToString();
item.Type = reader["Type"].ToString();
item.Wkn = reader["WKN"].ToString();
Items.Add(item.OldId, item);
}
}
}
}
//Import
foreach (var item in Items.Where(i => !i.Value.IsDividend))
{
var cmd = new StockAddCommand(
item.Value.Id,
-1,
item.Value.Name,
item.Value.Wkn,
item.Value.Type,
item.Value.LongShort);
CommandDispatcher.Execute(cmd);
LoggingService.Info($"Stock {item.Value.Name} (Old ID:{item.Value.OldId}, New ID:{item.Value.Id})");
}
}
public void NullTestPut()
{
//Arrange
Mock <IStockRepository> mockStockRepository =
new Mock <IStockRepository>();
StockDto stock = null;
IStockApplicationService stocksApplicationService = new StockApplicationService(mockStockRepository.Object);
//Act & Assert
Assert.Throws <NullReferenceException>(() => stocksApplicationService
.SaveStock(stock));
}
public void Save(StockDto dto)
{
if (dto.IsNew)
{
Stock stock = dto.MapTo <Stock>();
this._repository.Insert(stock);
}
else
{
Stock stock = this._repository.Get(dto.Id);
dto.MapTo(stock);
}
}
private void SendStockToWeb(DataTable data)
{
if (data.Rows.Count.Equals(0))
{
return;
}
foreach (DataRow row in data.Rows)
{
StockDto dto = new StockDto();
dto.ProductId = row["id_producto"].ToString();
dto.Stock = int.Parse(row["diferencia"].ToString());
notifier.Notify("maipogrande", "Product", "UpdateStock", dto);
}
}
public void NullTestPut()
{
//Arrange
Mock <IStockApplicationService> mockStockApplicationService =
new Mock <IStockApplicationService>();
StockDto stock = null;
StocksController stocksController = new StocksController(mockStockApplicationService.Object);
//Act
IActionResult actionResult = stocksController.Post(stock);
//Assert
Assert.IsType <BadRequestObjectResult>(actionResult);
}
public StockDto GetStockDto(Stock stock, CityBuilding flowController, CityBuilding quarry, Laboratory laboratory)
{
var stockDto = new StockDto
{
CoralAmount = stock.CoralAmount,
PearlAmount = stock.PearlAmount,
StoneAmount = stock.StoneAmount,
PearlIncome = GetPearlIncome(flowController, laboratory),
CoralIncome = GetCoralIncome(flowController, laboratory, null),
StoneIncome = GetStoneIncome(quarry, laboratory)
};
return(stockDto);
}
protected async override Task CrearNuevoElemento()
{
if (Stock.Material != null)
{
Stock.FechaActualizacion = DateTime.Now;
Stock.UsuarioId = UsuarioGral.UsuarioId;
Stock.MaterialId = Stock.Material.Id;
await Servicios.ApiProcessor.PostApi(Stock, "Stock/Insert");
await Inicializar();
Stock = null;
Stock = new StockDto();
}
}
public void Update(StockDto entityDto)
{
try
{
var entity = Mapper.Map <StockDto, Stock>(entityDto);
_unitOfWork.Stocks.Update(entity);
_unitOfWork.Complete();
}
catch (Exception)
{
// TODO lav exception
throw;
}
}
private void ImportSplit(DateTime orderDate, StockDto stock, decimal newShares, decimal newPrice)
{
//Import
var cmd = new TransactionSplitCommand(
Guid.NewGuid(),
-1,
orderDate,
newShares,
newPrice,
stock.Id);
CommandDispatcher.Execute(cmd);
LoggingService.Info($"Split {stock.Name} ({newShares} x {newPrice})");
}
public async Task <Maybe <StockDto> > AddAsync(StockDto model)
{
try
{
Stock detail = mapper.Map <Stock>(model);
var addedEntity = dBContext.Stocks.Add(detail);
await dBContext.SaveChangesAsync();
return(Maybe.Ok(addedEntity.Entity.ToModel <StockDto>(mapper)));
}
catch (Exception ex)
{
return(Maybe.Fail <StockDto>("Can't do AddAsync.", ex));
}
}
public async void PatchStockByDtoAsync_ReturnsCorrectResult()
{
var repo = new Mock <IStockRepository>();
repo.Setup(x => x.GetOneAsync(It.IsAny <string>())).ReturnsAsync((string code) => {
Stock theStock = fakeStocks.FirstOrDefault <Stock>(s => s.Code == code);
if (theStock == null)
{
throw new NotFoundInDbException();
}
else
{
return(theStock);
}
})
.Verifiable();
repo.Setup(x => x.UpdateAsync(It.IsAny <Stock>())).Callback((Stock oldStock) => {
if (!fakeStocks.Any(s => s.Code == oldStock.Code))
{
throw new NotFoundInDbException();
}
});
var service = new StockService(repo.Object);
StockDto stockDto = new StockDto("TSC", 81);
await service.PatchStockAsync(stockDto);
repo.Verify();
repo.Verify(t => t.UpdateAsync(It.IsAny <Stock>()), Times.Once());
StockDto stockDto2 = stockDto with {
Code = "XXX"
};
try
{
await service.PatchStockAsync(stockDto2);
}
catch (Exception ex)
{
Assert.Equal("NotFoundInDbException", ex.GetType().Name);
repo.Verify();
repo.Verify(t => t.UpdateAsync(It.IsAny <Stock>()), Times.Once());
}
}
}
/// <summary>
/// validating stock object.
/// </summary>
/// <param name="stock">stock object</param>
/// <returns>isValid</returns>
public bool IsPostValid(StockDto stock)
{
bool isValid = true;
if (stock.TotalPrice <= 0 || stock.TotalPrice == 0)
{
isValid = false;
}
if (stock.TotalQuantity <= 0 || stock.TotalQuantity == 0)
{
isValid = false;
}
return(isValid);
}
public async Task <Maybe <StockDto> > UpdateAsync(StockDto model)
{
try
{
var existingEntity = await dBContext.Stocks.FirstOrDefaultAsync(d => d.Name == model.Name);
existingEntity.Quantity = existingEntity.Quantity + model.Quantity;
await dBContext.SaveChangesAsync();
return(Maybe.Ok <StockDto>(existingEntity.ToModel <StockDto>(mapper)));
}
catch (Exception ex)
{
return(Maybe.Fail <StockDto>("Can't do UpdateAsync.", ex));
}
}
/// <summary>
/// saving the stock object.
/// </summary>
/// <param name="stockDto">stock object that want to save.</param>
/// <returns>saved stock object</returns>
public Domain.Stock.Model.Stock SaveStock(StockDto stockDto)
{
StockValidator validator = new StockValidator();
bool isValid = validator.IsPostValid(stockDto);
StockMapper modelMapper = new StockMapper();
Domain.Stock.Model.Stock stockEntity = modelMapper.EntityFrom(stockDto);
if (!isValid || stockEntity == null)
{
throw new NullReferenceException();
}
IList <Domain.Products.Model.Product> productEntities = modelMapper.ProductDtoFrom(stockDto);
stockEntity.CreatedOn = DateTime.Now;
Domain.Stock.Model.Stock result = this._stockRepository.SaveStock(stockEntity, productEntities);
return(stockEntity);
}
