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