public void Add_Stock_Test()
{
//Arrage
Stock newCommonStock = new StockCommon("TEA", 100, 0, 50);
//Act
_stocksRepository.Add(newCommonStock);
//Assert
Assert.AreEqual(1, _stocksRepository.GetAll().Count);
}
public async Task AddStockAsync(Stock stock)
{
try
{
int count = await Task.Run(() => _stockRepository.GetTotalCount(stock.Type));
stock.Name = string.Format("{0}{1}", stock.Type, count + 1);
stock.MarketValue = stock.Price * stock.Quantity;
if (stock.Type == StockType.Bond)
{
stock.TransactionCost = stock.MarketValue * BondTransactionCostPercent;
}
if (stock.Type == StockType.Equity)
{
stock.TransactionCost = stock.MarketValue * EquityTransactionCostPercent;
}
await Task.Run(() => _stockRepository.Add(stock));
_log.Debug(string.Format("Successfully add new stock. StockName [{0}]", stock.Name));
}
catch (Exception ex)
{
_log.Error("An error occured while adding new stock.", ex);
throw;
}
}
public IActionResult CreateCar([FromBody] Stock stock)
{
EnsureArg.IsNotNull(stock);
stockService.Add(stock);
return(Ok());
//return CreatedAtRoute()
}
/// <summary>
/// Method used to save stock productivity
/// </summary>
/// <param name="stock">The stock info</param>
/// <param name="productivity">The productivity info</param>
public void SaveStockProductivity(Stock stock, IEnumerable <Productivity> productivity)
{
if (stock == null)
{
return;
}
_stockRepository.Add(stock, productivity);
}
public bool Add(Stock stock, out string message)
{
message = "";
if (stock != null)
{
return(_stockRepository.Add(stock, out message));
}
return(false);
}
static void SetUpData()
{
_stockRepository.Add(new StockCommon("TEA", 100, 0, 100));
_stockRepository.Add(new StockCommon("POP", 100, 8, 100));
_stockRepository.Add(new StockCommon("ALE", 60, 23, 60));
_stockRepository.Add(new StockPreferred("GIN", 100, 8, 100, 2));
_stockRepository.Add(new StockCommon("JOE", 250, 13, 250));
_stockService = new StocksService(_stockRepository);
_tradeRepository.Add(new Trade(new StockCommon("TEA", 100, 0, 100), DateTime.Now.AddMinutes(-5), 3, Trade.TradeType.Buy, 23));
_tradeRepository.Add(new Trade(new StockCommon("TEA", 100, 0, 100), DateTime.Now.AddMinutes(5), 3, Trade.TradeType.Buy, 33));
_tradeRepository.Add(new Trade(new StockCommon("POP", 100, 8, 100), DateTime.UtcNow.AddMinutes(-5), 4, Trade.TradeType.Buy, 33));
_tradeRepository.Add(new Trade(new StockCommon("ALE", 60, 23, 60), DateTime.UtcNow.AddMinutes(-1), 5, Trade.TradeType.Buy, 23));
_tradeRepository.Add(new Trade(new StockPreferred("GIN", 100, 8, 100, 2), DateTime.UtcNow.AddMinutes(-1), 6, Trade.TradeType.Buy, 23));
_tradeRepository.Add(new Trade(new StockCommon("JOE", 250, 13, 250), DateTime.UtcNow.AddMinutes(-1), 7, Trade.TradeType.Buy, 23));
_tradeService = new TradeService(_tradeRepository);
}
public ApiResultModel <int> AddStock(Stock model)
{
var result = new ApiResultModel <int>();
_stockRepository.Add(model);
_stockRepository.SaveChanges();
result.Code = ApiResultCode.Success;
return(result);
}
public void AddOrUpdate(Stock stock)
{
if (stock.Id == 0)
{
_repository.Add(stock);
}
else
{
_repository.Update(stock);
}
}
public async Task <IActionResult> Create([Bind("Id,Name,Code")] StockModel stockModel)
{
if (ModelState.IsValid)
{
stockModel.Id = Guid.NewGuid();
Stock stock = Stock.Create(stockModel.Id, stockModel.Name, stockModel.Code);
_stockRepo.Add(stock);
return(RedirectToAction(nameof(Index)));
}
return(View(stockModel));
}
public async Task <IActionResult> CreateStock([FromBody] StockModel data)
{
var existing = await _stockRepository.FindAsync(data.Symbol);
if (existing != null)
{
return(Conflict($"Stock {data.Symbol} already exists"));
}
var stock = _stockRepository.Add(new Stock(data.Symbol));
await _stockRepository.UnitOfWork.SaveEntitiesAsync();
return(Ok(stock));
}
public void AddOrUpdate(Stock model)
{
Stock stock = new Stock();
model.CopyTo(stock);
if (stock.Id == 0)
{
_repository.Add(stock);
}
else
{
_repository.Update(stock);
}
}
public async Task Post([FromBody] string value)
{
var account = new Account("Yang Zhang", "*****@*****.**", AccountStatus.Created);
var stock = await _stockRepository.FindAsync("GOOG");
if (stock == null)
{
stock = new Stock("GOOG");
stock.AddStockPrice(1020, DateTime.Now);
_stockRepository.Add(stock);
}
account.AddTransaction(stock.Id, 100, 1020, TransactionType.Buy, 10, DateTime.Now);
_accountRepository.Add(account);
await _accountRepository.UnitOfWork.SaveEntitiesAsync();
}
public Task <bool> Handle(AddNewStockCommand message, CancellationToken cancellationToken)
{
if (!message.IsValid())
{
NotifyValidationErrors(message);
return(Task.FromResult(false));
}
var stock = new Stock(Guid.NewGuid(), message.Name, message.Price);
_stockRepository.Add(stock);
if (Commit())
{
_bus.RaiseEvent(new StockAddedEvent(stock.Id, stock.Name, stock.Price));
}
return(Task.FromResult(true));
}
public Stock UpdateStock(Stock stockItem)
{
return(ExecuteFaultHandledOperation(() =>
{
IStockRepository stockRepository = _dataRepositoryFactory.GetDataRepository <IStockRepository>();
Stock updatedEntity = null;
if (stockItem.Id == 0)
{
updatedEntity = stockRepository.Add(stockItem);
}
else
{
updatedEntity = stockRepository.Update(stockItem);
}
return updatedEntity;
}));
}
private async Task <bool> SaveMovementTypes()
{
List <StockMovementType> defaultMovementTypes = new List <StockMovementType>()
{
new StockMovementType()
{
Name = "Initial balance"
},
new StockMovementType()
{
Name = "Normal"
},
new StockMovementType()
{
Name = "Supplier purchase"
},
new StockMovementType()
{
Name = "User purchase"
},
new StockMovementType()
{
Name = "Warehouse review"
}
};
IEnumerable <StockMovementType> existingMovementTypes = _stockRepo.GetMovementTypes();
foreach (StockMovementType movementType in defaultMovementTypes)
{
if (!existingMovementTypes.Any(m => m.Name == movementType.Name))
{
_stockRepo.Add(movementType);
}
}
return(await _stockRepo.SaveAllAsync());
}
public void AddStock(Stock entity)
{
ValidateStockEntity(entity);
UpdateStockHistory(entity);
_stockRepository.Add(entity);
}
public void Add(Stock entity)
{
stockRepository.Add(entity);
}
public bool Add(StockHeader entity)
{
return(_repository.Add(entity));
}
public async Task <Result> AddAsync(Dtos.ProductAddDto productDto)
{
var result = await Task.Run(() =>
{
var result = new Result();
// add product
var new_product = productDto.CreateProduct();
var new_stock = productDto.CreateStock(new_product.Id);
var exist_Product_Spec = new ProductSameExistSpecification(new_product);
// is specification satisfied?
var isStaisfy = exist_Product_Spec.IsSatisfiedBy(new_product);
if (isStaisfy)
{
var exist_product = _productRepository.Find(exist_Product_Spec).FirstOrDefault();
if (exist_product == null)
{
_productRepository.Add(new_product);
_productRepository.Complete();
var add_product_event = AbstractDomainEvent <ProductAddDto> .Create(_serviceProvider);
add_product_event.Raise(new_product);
}
else
{
result.IsError = true;
result.Message = "Product exist already";
result.StatuCode = 400;
}
}
if (!result.IsError)
{
// add stock
var stock_Spec = new StockExistSpecification(new_stock);
var exist_Stock = _stockRepository.Find(stock_Spec).FirstOrDefault();
// always statify ATM
var isSatisfy = stock_Spec.IsSatisfiedBy(new_stock);
if (isSatisfy)
{
if (exist_Stock == null)
{
_stockRepository.Add(new_stock);
_stockRepository.Complete();
var add_stock_event = AbstractDomainEvent <StockAddDto> .Create(_serviceProvider);
add_stock_event.Raise(new_stock);
}
else
{
result.IsError = true;
result.Message = "Stock exist already";
result.StatuCode = 400;
return(result);
}
}
}
return(result);
});
return(result);
}
public bool Add(AssetPurchaseHeader entity)
{
return(_stockRepository.Add(entity));
}
public void AddStock(StockDTO stock, StatisticsDTO statistics)
{
repo.Add(Mapper.Map <Stock>(stock));
statistics.InsertsTime += repo.LastOperationTime;
statistics.InsertsCount++;
}
public void Insert(Stock entity)
{
_stockRepository.Add(entity);
}
