public int Create(Entity entity)
{
var em = _domainService.Domain.Entities[entity.Name];
CheckEntityRules(entity, em);
StringBuilder sb = new StringBuilder();
sb.AppendFormat("INSERT INTO [{0}] (", entity.Name);
foreach (var pm in em.Properties.Where(p => p.Type == PropertyType.Sequence))
{
var sqpm = (SequencePropertyModel)pm;
if (sqpm.SequenceType != SequenceType.Identity)
{
var value = _sequenceProvider.GetNext(sqpm);
entity.Data[sqpm.Name] = value;
}
}
string[] columns = new string[entity.Data.Count];
string[] parameters = new string[entity.Data.Count];
int idx = 0;
SqlCommand cmd = new SqlCommand();
foreach (var data in entity.Data)
{
var pm = em.Properties[data.Key];
columns[idx] = string.Format("[{0}]", pm.Name);
parameters[idx] = string.Format("@{0}", pm.Name);
cmd.Parameters.AddWithValue(pm.Name, data.Value != null ? data.Value : DBNull.Value);
idx++;
}
using (var ctx = _dbService.GetDatabaseContext(true))
{
var sql = string.Format("INSERT INTO [{0}] ({1}) OUTPUT INSERTED.ID VALUES ({2})", em.Name, string.Join(",", columns), string.Join(",", parameters));
cmd.CommandText = sql;
cmd.Connection = ctx.Connection;
try
{
int id = (Int32)cmd.ExecuteScalar();
entity.Id = id;
ctx.Complete();
return(id);
}
catch (SqlException sex)
{
throw WrapSqlException(sex, em);
}
}
}
public OrderCommandsHandler(ISequenceProvider sequenceProvider)
{
Map <CreateOrderCommand>(c => new Order(c.OrderId, sequenceProvider.GetNext(OrdersSequenceName), c.UserId));
Map <AddItemToOrderCommand>((c, a) => a.AddItem(c.SkuId, c.Quantity, c.TotalPrice));
Map <CalculateOrderTotalCommand>((c, a) => a.CalculateTotal());
Map <CompleteOrderCommand>((c, a) => a.Complete());
}
public async Task <UserCreatedViewModel> CreateUser([FromBody] CreateUserViewModel userViewModel)
{
var createUserCommand = new CreateUserCommand(Guid.NewGuid(), userViewModel.Login, Guid.NewGuid());
var accountNumber = _accountNumberProvider.GetNext(AccountSequenceName);
var createAccountCommand = new CreateAccountCommand(createUserCommand.AccountId, createUserCommand.UserId, accountNumber);
await _commandBus.Execute(createUserCommand);
await _commandBus.Execute(createAccountCommand);
return(new UserCreatedViewModel(createUserCommand.UserId, createAccountCommand.AccountId, accountNumber));
}
private SkuStockHistory CreateHistory(SkuStock skuStock, StockOperation stockOperation, int quantity)
{
return(new SkuStockHistory
{
OldAvailableQuantity = skuStock.AvailableQuantity,
OldTotalQuantity = skuStock.TotalQuantity,
OldReservedQuantity = skuStock.ReservedQuantity,
Operation = stockOperation,
Quanity = quantity,
StockId = skuStock.Id,
Number = _sequenceProvider.GetNext(SkuHistorySequenceName)
});
}
public SkuCommandsHandler(ISequenceProvider provider)
{
Map <CreateNewSkuCommand>(c => new Sku(c.SkuId, c.Name, c.Article, (int)provider.GetNext("Sku"), c.Price));
}
private ModelNodeId CreateModelNodeId() => new ModelNodeId(_sequenceProvider.GetNext());
protected TestLayoutVertex CreateTestLayoutVertex([NotNull] string name, int priority = 1)
{
var id = _sequenceProvider.GetNext();
return(new TestLayoutVertex(id, name, priority));
}
/// <summary>
/// Liefert den Wert der Sequenz und setzt diese einen Schritt weiter.
/// Falls die Sequenz nicht existiert, wird sie angelegt mit dem gegebenen Startwert.
/// </summary>
/// <param name="sequenceId">Bezeichnung der Sequenz.</param>
/// <param name="startValue">Erster wert für die Sequenz.</param>
/// <returns>Den Wert der Sequenz oder null falls die Sequenz nicht existiert.</returns>
public int GetNext(string sequenceId, int startValue)
{
return(parent.GetNext(BuildSequenceId(sequenceId), startValue));
}