public void ProcessMessage(IHandlerContext <RegisterArgumentCommand> context)
{
var message = context.Message;
if (string.IsNullOrEmpty(message.Name) ||
string.IsNullOrEmpty(message.DataTypeName))
{
return;
}
using (_databaseContextFactory.Create())
{
var key = Argument.Key(message.Name);
var existingId = _keyStore.Get(key);
if (!message.Id.Equals(existingId ?? message.Id))
{
return;
}
var stream = _eventStore.Get(message.Id);
var argument = new Argument(stream.Id);
stream.Apply(argument);
_keyStore.Remove(Argument.Key(argument.Name));
stream.AddEvent(argument.Register(message.Name, message.DataTypeName));
_eventStore.Save(stream);
_keyStore.Add(argument.Id, key);
}
}
public void Initialize(IServiceBus bus)
{
_serviceBusConfiguration = bus.Configuration;
using (_databaseContextFactory.Create(SqlServerConfiguration.ProviderName, _subscriptionConnectionString))
{
if (_databaseGateway.GetScalarUsing <int>(
RawQuery.Create(
_scriptProvider.GetScript(
Script.SubscriptionManagerExists))) != 1)
{
try
{
_databaseGateway.ExecuteUsing(RawQuery.Create(
_scriptProvider.GetScript(
Script.SubscriptionManagerCreate)));
}
catch (Exception ex)
{
if (!ex.Message.Equals("There is already an object named 'SubscriberMessageType' in the database.", StringComparison.OrdinalIgnoreCase))
{
throw new DataException(SqlResources.SubscriptionManagerCreateException, ex);
}
}
}
}
if (HasDeferredSubscriptions)
{
Subscribe(_deferredSubscriptions);
}
}
private void Connect()
{
if (string.IsNullOrEmpty(ConnectionString.Text))
{
return;
}
_tables.Clear();
try
{
using (_databaseContextFactory.Create("System.Data.SqlClient", ConnectionString.Text))
{
foreach (
var row in
_databaseGateway.GetRowsUsing(
RawQuery.Create("select TABLE_NAME from INFORMATION_SCHEMA.TABLES order by 1")))
{
_tables.Add(row[0].ToString());
}
}
FilterTables();
SaveConnectionString();
}
catch (Exception ex)
{
ShowMessage(ex.AllMessages());
}
}
public void ProcessMessage(IHandlerContext <AddRoleCommand> context)
{
var message = context.Message;
if (string.IsNullOrEmpty(message.Name))
{
return;
}
using (_databaseContextFactory.Create())
{
var key = Role.Key(message.Name);
if (_keyStore.Contains(key))
{
return;
}
var id = Guid.NewGuid();
_keyStore.Add(id, key);
var role = new Role(id);
var stream = _eventStore.CreateEventStream(id);
stream.AddEvent(role.Add(message.Name));
_eventStore.Save(stream);
}
}
public async Task <IEnumerable <ChatMessageDto> > GetMessages(int chatRoomId)
{
using (var dbContext = _dbContextFactory.Create())
{
return(_mapper.Map <IEnumerable <ChatMessageDto> >(await dbContext.ChatMessages.Include(m => m.User).Where(m => m.ChatRoomId == chatRoomId).Take(100).ToListAsync()));
}
}
public void Add(TEntity entity)
{
using (_unitOfWork = new UnitOfWork(_databaseContextFactory.Create()))
{
_unitOfWork.context.Set <TEntity>().Add(entity);
_unitOfWork.Commit();
}
}
public ProjectionEvent GetEvent(long sequenceNumber)
{
using (
_databaseContextFactory.Create(_projectionConfiguration.ProviderName, _projectionConfiguration.ConnectionString))
{
return(ProjectionEvent(_databaseGateway.GetSingleRowUsing(_queryFactory.Get(sequenceNumber))));
}
}
public long GetSequenceNumber(string name)
{
using (
_databaseContextFactory.Create(_projectionConfiguration.ProviderName, _projectionConfiguration.ConnectionString))
{
return(_databaseGateway.GetScalarUsing <long>(_queryFactory.GetSequenceNumber(name)));
}
}
public void ProcessMessage(IHandlerContext <AddMessageHeaderCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
_messageHeaderQuery.Save(message.Id, message.Key, message.Value);
}
}
public List <T> GetAll()
{
using (var db = dbContextFactory.Create())
{
return(GetDbSet(db)
.Select(entry => entry)
.ToList());
}
}
public IActionResult Get()
{
using (_databaseContextFactory.Create())
{
return(Ok(new
{
Data = Data(_queueQuery.All())
}));
}
}
/// <summary>
/// 创建
/// </summary>
/// <param name="sample">EFSample</param>
/// <returns></returns>
public bool Create(EfSample sample)
{
using (IDbContext context = _contextFactory.Create())
{
return(context.Create(sample));
}
}
/// <summary>
/// 创建
/// </summary>
/// <param name="samle">EFSample</param>
/// <returns></returns>
public bool Create(EFSample samle)
{
using (IDbContext dbcontext = _contextFactory.Create())
{
return(dbcontext.Create <EFSample>(samle));
}
}
public IActionResult Get()
{
using (_databaseContextFactory.Create())
{
return(Ok(new
{
Data = from message in _inspectionQueue.Messages().ToList()
select PresentationMessage(message)
}));
}
}
public IActionResult Get()
{
using (_databaseContextFactory.Create())
{
return(Ok(new
{
Data = _documentQuery.Search(new DataAccess.Query.Document.Specification()
.IncludeProperties()
.IncludeStatusEvents()
.GetMaximumRows(30))
}));
}
}
public IActionResult Search([FromBody] FormulaSearchModel model)
{
Guard.AgainstNull(model, nameof(model));
using (_databaseContextFactory.Create())
{
return(Ok(new
{
Data = _dataRowMapper.MapObjects <FormulaModel>(
_formulaQuery.Search(model.Specification()))
}));
}
}
/// <summary>
/// 创建
/// </summary>
/// <param name="samle">EFSample</param>
/// <returns></returns>
public bool Create(EfSample samle)
{
using (var dbcontext = _contextFactory.Create())
{
return(dbcontext.Create(samle));
}
}
public RegisterSessionResult Register(string username, string password, Guid token)
{
if (string.IsNullOrEmpty(username) || (string.IsNullOrEmpty(password) && token.Equals(Guid.Empty)))
{
return(RegisterSessionResult.Failure());
}
Session session;
if (!string.IsNullOrEmpty(password))
{
var authenticationResult = _authenticationService.Authenticate(username, password);
if (!authenticationResult.Authenticated)
{
return(RegisterSessionResult.Failure());
}
session = new Session(Guid.NewGuid(), username, DateTime.Now);
foreach (var permission in _authorizationService.Permissions(username, authenticationResult.AuthenticationTag))
{
session.AddPermission(permission);
}
using (_databaseContextFactory.Create(_configuration.ProviderName, _configuration.ConnectionString))
{
_sessionRepository.Save(session);
}
}
else
{
using (_databaseContextFactory.Create(_configuration.ProviderName, _configuration.ConnectionString))
{
session = _sessionRepository.Get(token);
if (session == null)
{
return(RegisterSessionResult.Failure());
}
session.Renew();
_sessionRepository.Renewed(session);
}
}
return(RegisterSessionResult.Success(session.Token, session.Permissions));
}
public async Task <IEnumerable <ICity> > GetAllAsync()
{
using (var databaseContext = _databaseContextFactory.Create())
{
var cityEntities = await databaseContext
.City
.ToListAsync();
var cities = cityEntities
.Select(entity => _cityFactory.Create(entity.Name, entity.Code))
.ToArray();
return(cities);
}
}
public void ProcessMessage(IHandlerContext <AddDataStoreCommand> context)
{
var message = context.Message;
using (_databaseContextFactory.Create())
{
_dataStoreQuery.Add(new DataStore
{
Id = Guid.NewGuid(),
Name = message.Name,
ConnectionString = message.ConnectionString,
ProviderName = message.ProviderName
});
}
}
public void ProcessMessage(IHandlerContext <ArchiveOrderProcessCommand> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var orderProcess = _repository.Get(context.Message.OrderProcessId);
if (!orderProcess.CanArchive())
{
context.Publish(new ArchiveOrderProcessRejectedEvent
{
OrderProcessId = context.Message.OrderProcessId,
Status = orderProcess.Status().Status
});
return;
}
_repository.Remove(orderProcess);
}
context.Publish(new OrderProcessArchivedEvent
{
OrderProcessId = context.Message.OrderProcessId
});
}
public void ProcessMessage(IHandlerContext <ArchiveOrderProcessCommand> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(context.Message.OrderProcessId);
var orderProcess = new OrderProcess(context.Message.OrderProcessId);
stream.Apply(orderProcess);
if (!orderProcess.CanArchive)
{
context.Publish(new ArchiveOrderProcessRejectedEvent
{
OrderProcessId = context.Message.OrderProcessId,
Status = orderProcess.Status
});
return;
}
stream.AddEvent(orderProcess.ChangeStatus("Order Archived"));
_eventStore.SaveEventStream(stream);
}
context.Publish(new OrderProcessArchivedEvent
{
OrderProcessId = context.Message.OrderProcessId
});
}
public void ProcessMessage(IHandlerContext <EMailSentEvent> context)
{
if (!context.TransportMessage.IsHandledHere())
{
return;
}
var orderProcessId = new Guid(context.TransportMessage.CorrelationId);
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(orderProcessId);
if (stream.IsEmpty)
{
throw new ApplicationException(
string.Format("Could not find an order process with correlation id '{0}'.",
context.TransportMessage.CorrelationId));
}
var orderProcess = new OrderProcess(orderProcessId);
stream.Apply(orderProcess);
stream.AddEvent(orderProcess.ChangeStatus("Dispatched-EMail Sent"));
_eventStore.SaveEventStream(stream);
}
context.Send(new CompleteOrderProcessCommand
{
OrderProcessId = orderProcessId
}, c => c.Local());
}
public void ProcessMessage(IHandlerContext <CancelOrderProcessRejectedEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.SaveStatus(context.Message.OrderProcessId, context.Message.Status);
}
}
public void ProcessMessage(IHandlerContext <CreateOrderCommand> context)
{
// simulate slow processing
Thread.Sleep(1000);
var message = context.Message;
var order = new Order(message.OrderNumber, message.OrderDate)
{
Customer = new OrderCustomer(message.CustomerName, message.CustomerEMail)
};
foreach (var item in message.Items)
{
order.AddItem(item.Description, item.Price);
}
using (_databaseContextFactory.Create(OrderingData.ConnectionStringName))
{
_repository.Add(order);
}
var orderCreatedEvent = new OrderCreatedEvent
{
OrderId = order.Id,
OrderNumber = message.OrderNumber,
OrderDate = message.OrderDate,
CustomerName = message.CustomerName,
CustomerEMail = message.CustomerEMail
};
orderCreatedEvent.Items.AddRange(message.Items);
context.Publish(orderCreatedEvent);
}
public void ProcessMessage(IHandlerContext <InvoiceCreatedEvent> context)
{
if (!context.TransportMessage.IsHandledHere())
{
return;
}
var orderProcessId = new Guid(context.TransportMessage.CorrelationId);
var orderProcess = new OrderProcess(orderProcessId);
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(orderProcessId);
if (stream.IsEmpty)
{
throw new ApplicationException(
string.Format("Could not find an order process with correlation id '{0}'.",
context.TransportMessage.CorrelationId));
}
stream.Apply(orderProcess);
stream.AddEvent(orderProcess.ChangeStatus("Invoice Created"));
stream.AddEvent(orderProcess.AssignInvoiceId(context.Message.InvoiceId));
_eventStore.Save(stream);
}
context.Send(orderProcess.SendEMailCommand());
}
public void ProcessMessage(IHandlerContext <OrderProcessRegisteredEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.Add(context.Message);
}
}
public void ProcessMessage(IHandlerContext <CancelOrderProcessCommand> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
var stream = _eventStore.Get(context.Message.OrderProcessId);
var orderProcess = new OrderProcess(context.Message.OrderProcessId);
stream.Apply(orderProcess);
if (!orderProcess.CanCancel)
{
context.Publish(new CancelOrderProcessRejectedEvent
{
OrderProcessId = context.Message.OrderProcessId,
Status = orderProcess.Status
});
return;
}
_eventStore.Remove(context.Message.OrderProcessId);
}
context.Publish(new OrderProcessCancelledEvent
{
OrderProcessId = context.Message.OrderProcessId
});
}
public void ProcessMessage(IHandlerContext <OrderCreatedEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.SaveStatus(context.TransportMessage.OrderProcessId(), "Order Created");
}
}
public void ProcessMessage(IHandlerContext <OrderProcessCancelledEvent> context)
{
using (_databaseContextFactory.Create(ProcessManagementData.ConnectionStringName))
{
_orderProcessViewQuery.Remove(context.Message.OrderProcessId);
}
}
