public void ThrowsArgumentExceptionForNullTypes()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var dependencyResolver = serviceLocator.ResolveType <IDependencyResolver>();
ExceptionTester.CallMethodAndExpectException <ArgumentException>(() => dependencyResolver.CanResolveMultiple(null));
}
public void ReturnsTrueForEmptyArray()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var dependencyResolver = serviceLocator.ResolveType <IDependencyResolver>();
Assert.IsTrue(dependencyResolver.CanResolveMultiple(new Type[] { }));
}
public void ThrowsTypeNotRegisteredForNonRegisteredType()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var dependencyResolver = serviceLocator.ResolveType <IDependencyResolver>();
ExceptionTester.CallMethodAndExpectException <TypeNotRegisteredException>(() => dependencyResolver.Resolve(typeof(ITestInterface)));
}
public void ReturnsFalseForNonRegisteredType()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var dependencyResolver = serviceLocator.ResolveType <IDependencyResolver>();
Assert.IsFalse(dependencyResolver.CanResolve(typeof(ITestInterface)));
}
public MessageSender(IMessageQueueClient messageQueueClient, string defaultTopic = null)
{
_messageQueueClient = messageQueueClient;
_defaultTopic = defaultTopic;
_messageQueue = new BlockingCollection <IMessageContext>();
_logger = IoCFactory.Resolve <ILoggerFactory>().Create(this.GetType());
}
static void ServiceTest()
{
ReduceProduct reduceProduct = new ReduceProduct
{
ProductId = new Guid("2B6FDE83-A319-433B-9FA5-399D382D0CD3"),
ReduceCount = 1
};
var _commandBus = IoCFactory.Resolve <ICommandBus>();
_commandBus.Start();
var t = _commandBus.SendAsync(reduceProduct, true).Result;
Console.WriteLine(t.Reply.Result);
var products = _commandBus.SendAsync(new GetProducts
{
ProductIds = new List <Guid> {
reduceProduct.ProductId
}
}, true).Result.ReadAsAsync <List <Project> >().Result;
Console.WriteLine(products.ToJson());
Console.ReadLine();
}
IEnumerable <IMessageContext> GetAllUnSentMessages <TMessage>()
where TMessage : UnSentMessage
{
var messageContexts = new List <IMessageContext>();
this.Set <TMessage>().ToList().ForEach(message =>
{
try
{
var rawMessage = message.MessageBody.ToJsonObject(Type.GetType(message.Type)) as IMessage;
if (rawMessage != null)
{
var messageContext = IoCFactory.Resolve <IMessageContext>("MessageStoreMapping", new ParameterOverride("message", rawMessage));
messageContexts.Add(messageContext);
}
else
{
this.Set <TMessage>().Remove(message);
_logger.ErrorFormat("get unsent message error: {0}", message.ToJson());
}
}
catch (Exception)
{
this.Set <TMessage>().Remove(message);
_logger.ErrorFormat("get unsent message error: {0}", message.ToJson());
}
});
SaveChanges();
return(messageContexts);
}
/// <summary>
/// 根据名称获取领域仓储
/// </summary>
/// <typeparam name="TDomainRespository">领域仓储类型</typeparam>
/// <param name="name">名称</param>
/// <returns>领域仓储</returns>
public IDomainRepository GetDomainRepository <TDomainRespository>(string name) where TDomainRespository : IDomainRepository
{
var repository = IoCFactory.Resolve <TDomainRespository>(name);
repository.Join(this);
return(repository);
}
public void TheOpenedActionIsCalledWhenViewManagerHaveRegisteredAViewForTheViewModel()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock <IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny <Action>(), true)).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock <IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(new Task <bool>(() => true));
var viewManagerMock = new Mock <IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { new FooViewModelView(fooViewModel) });
serviceLocator.RegisterInstance <IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance <IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
serviceLocator.ResolveType <IUIVisualizerService>().Show(fooViewModel, () =>
{
visualizerServiceMock.Verify(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
this.EnqueueTestComplete();
});
}
public MessageProcessor(string serviceBusConnectionString)
{
_serviceBusConnectionString = serviceBusConnectionString;
_logger = IoCFactory.Resolve <ILoggerFactory>().Create(this.GetType());
_namespaceManager = NamespaceManager.CreateFromConnectionString(_serviceBusConnectionString);
_messageFactory = MessagingFactory.CreateFromConnectionString(_serviceBusConnectionString);
}
void PublishEvent()
{
try
{
while (true)
{
var eventContext = MessageQueue.Take();
while (true)
{
try
{
_topicClient.Send(((MessageContext)eventContext).BrokeredMessage);
Task.Factory.StartNew(() =>
{
using (var messageStore = IoCFactory.Resolve <IMessageStore>())
{
messageStore.RemovePublishedEvent(eventContext.MessageID);
}
});
break;
}
catch (Exception)
{
Thread.Sleep(1000);
}
}
}
}
catch (Exception ex)
{
_logger.Debug("end publish working", ex);
}
}
/// <summary>
/// process the order.
/// </summary>
/// <param name="order">Order to process.</param>
/// <returns>True if the operation was successful.</returns>
public bool ProcessOrder(Order order)
{
try
{
order.Items = IoCFactory.Resolve <IItemsRepository>().GetItemsByCustomer(order.CustomerId);
Product product = null;
foreach (var itm in order.Items)
{
product = IoCFactory.Resolve <IProductsServiceAgent>().GetProductById(itm.ProductId).Results.FirstOrDefault();
itm.Product = product;
}
bool answerServiceAgent = IoCFactory.Resolve <IOrdersServiceAgent>().ProcessOrder(order);
if (answerServiceAgent)
{
bool answerItems = IoCFactory.Resolve <IItemsRepository>().DeleteItemsByCustomerId(order.CustomerId);
}
return(answerServiceAgent);
}
catch (Exception ex)
{
throw new Exception("Se produjo un error al procesar la orden", ex);
}
}
/// <summary>
/// Get order by customer id.
/// </summary>
/// <param name="customerId">Identifier customer.</param>
/// <param name="lstProductsId">List of productIds.</param>
/// <param name="lstQuantitys"></param>
/// <returns>Order.</returns>
public Order GetOrderByCustomerId(int customerId, string lstItemsSerialized)
{
try
{
List <Item> lstItems = JsonSerializer.DeserializeObject <List <Item> >(lstItemsSerialized);
Order order = new Order()
{
CustomerId = customerId,
Items = lstItems,
OrderId = customerId,
};
Product product = null;
foreach (var itm in order.Items)
{
product = IoCFactory.Resolve <IProductsServiceAgent>().GetProductById(itm.ProductId).Results.FirstOrDefault();
itm.Product = product;
}
return(order);
}
catch (Exception ex)
{
throw new Exception("Se produjo un error al consultar la orden del cliente.", ex);
}
}
public static IContainer Create()
{
var container = ContainerFactory.Create();
var timeServiceMock = TimeServiceMockFactory.Create();
container.SetConstant <ITimeService, ITimeService>(timeServiceMock.Object);
var persistentServiceMock = PersistentServiceMockFactory.Create();
container.SetConstant <IPersistentService, IPersistentService>(persistentServiceMock.Object);
var encryptServiceMock = EncryptServiceMockFactory.Create();
container.SetConstant <IEncryptService, IEncryptService>(encryptServiceMock.Object);
Common.IoCRegistrator.RegisterValidateService(container);
IoCFactory.RegisterAssemblyTypes(container);
container.Remove <IHttpService>();
var httpServiceMock = HttpServiceMockFactory.Create();
container.SetConstant <IHttpService, HttpService>(httpServiceMock.Object);
var smtpServiceMock = new Mock <ISmtpService>(MockBehavior.Strict);
smtpServiceMock.Setup(m => m.SendEmail(It.IsAny <MailMessage>()));
container.SetConstant <ISmtpService, ISmtpService>(smtpServiceMock.Object);
return(container);
}
public EventPublisher(string serviceBusConnectionString, string topic)
{
_serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
MessageQueue = new BlockingCollection <IMessageContext>();
_logger = IoCFactory.Resolve <ILoggerFactory>().Create(this.GetType());
_topic = topic;
}
/// <summary>
/// 根据名称获取领域仓储
/// </summary>
/// <param name="name">名称</param>
/// <returns>仓储</returns>
public IDomainRepository GetDomainRepository(string name)
{
var repository = IoCFactory.Resolve <IDomainRepository>(name);
repository.Join(this);
return(repository);
}
private static void writeEvent()
{
ISerializer serializer = IoCFactory.Resolve <ISerializer>();
IEventPublisher eventPublisher = IoCFactory.Resolve <IEventPublisher>();
ImportLogDTO importLogDTO = new ImportLogDTO
{
Status = 1,
DeviceId = "PRUEBA123",
FileName = "PRUEBA.xml",
FileType = "PRE",
ImportDate = DateTime.Now,
Message = "PRUEBA MESSAGE",
TotalSeconds = 2,
StartDate = DateTime.Now.AddMinutes(-2),
EndDate = DateTime.Now
};
ImportEventDTO importEventDTO = new ImportEventDTO
{
importLog = importLogDTO
};
Event ev = new Event
{
Source = "UnPackerAdded",
EventType = "LoadProfile",
TriggeredAt = DateTime.Now,
Data = serializer.Serialize(importEventDTO)
};
////Escribe el evento en la cola.
eventPublisher.PublishEvent(ev);
}
/// <summary>
/// 根据名称获取仓储
/// </summary>
/// <typeparam name="TAggregateRoot">聚合根类型</typeparam>
/// <param name="name">名称</param>
/// <returns>仓储</returns>
public IRepository <TAggregateRoot> GetRepository <TAggregateRoot>(string name) where TAggregateRoot : class, IAggregateRoot
{
IRepository repository = null;
IRepository <TAggregateRoot> genericRepo = null;
if (repositories.TryGetValue(typeof(IRepository <TAggregateRoot>), out repository))
{
genericRepo = (IRepository <TAggregateRoot>)repository;
}
else
{
foreach (var entityRepository in EntityRepositoryMap)
{
if (typeof(TAggregateRoot).GetInterfaces().Contains(entityRepository.Key))
{
repository = (IRepository <TAggregateRoot>)IoCFactory.Resolve(entityRepository.Value.MakeGenericType(typeof(TAggregateRoot)), name);
}
}
if (repository == null)
{
repository = IoCFactory.Resolve <IRepository <TAggregateRoot> >(name);
}
repositories.Add(typeof(IRepository <TAggregateRoot>), repository);
genericRepo = (IRepository <TAggregateRoot>)repository;
genericRepo.Join(this);
}
return(genericRepo);
}
public void GenerateDistributorsReport_Database_Test()
{
var securityDatas =
new[]
{
new SecurityData {
Login = "******", Password = "******"
},
new SecurityData {
Login = "******", Password = "******"
},
new SecurityData {
Login = "******", Password = "******"
}
};
foreach (var securityData in securityDatas)
{
using (var container = IoCFactory.CreateContainer())
{
container.Get <ISecurityService>().LogIn(securityData);
var reportService = container.Get <IReportService>();
var items = reportService.GenerateDistributorsReport();
Assert.IsTrue(items.Length > 0);
container.Get <ISecurityService>().LogOut();
}
}
}
/// <summary>
/// Get the items of a customer.
/// </summary>
/// <param name="customerId">Customer Id.</param>
/// <param name="lstItemsSerialized">Serialized list items.</param>
/// <returns>List items.</returns>
public List <Item> GetItemsByCustomer(int customerId, string lstItemsSerialized)
{
try
{
List <Item> lstItems = JsonSerializer.DeserializeObject <List <Item> >(lstItemsSerialized);
List <Item> itemsCurrent = IoCFactory.Resolve <IItemsRepository>().GetItemsByCustomer(customerId);
foreach (var itm in lstItems)
{
Item item = itemsCurrent.FirstOrDefault(it => it.ProductId == itm.ProductId);
if (item != null)
{
item.Quantity += itm.Quantity;
IoCFactory.Resolve <IItemsRepository>().ModifyQuantityToItem(item);
}
else
{
IoCFactory.Resolve <IItemsRepository>().AddItem(itm, customerId);
}
}
return(IoCFactory.Resolve <IItemsRepository>().GetItemsByCustomer(customerId));
}
catch (Exception ex)
{
throw new Exception("Se produjo un error al consultar los items del cliente", ex);
}
}
public void TheOpenedActionIsCalledEvenWhenThereNoViewsAvailablesInTheExpectedTimeForTheCurrentViewModelButUnlockingTheInspectionThread()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var fooViewModel = new FooViewModel(serviceLocator);
var dispatcherServiceMock = new Mock <IDispatcherService>();
dispatcherServiceMock.Setup(service => service.Invoke(It.IsAny <Action>())).Callback((Action action) => action.Invoke());
var visualizerServiceMock = new Mock <IUIVisualizerService>();
visualizerServiceMock.Setup(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null)).Returns(true);
var viewManagerMock = new Mock <IViewManager>();
viewManagerMock.Setup(manager => manager.GetViewsOfViewModel(fooViewModel)).Returns(new IView[] { });
serviceLocator.RegisterInstance <IDispatcherService>(dispatcherServiceMock.Object);
serviceLocator.RegisterInstance <IUIVisualizerService>(visualizerServiceMock.Object);
serviceLocator.RegisterInstance <IViewManager>(viewManagerMock.Object);
serviceLocator.ResolveType <IUIVisualizerService>().Show(fooViewModel, () =>
{
visualizerServiceMock.Verify(service => service.Show(It.Is <FooViewModel>(model => ReferenceEquals(model, fooViewModel)), null), Times.Once());
viewManagerMock.Verify(manager => manager.GetViewsOfViewModel(fooViewModel), Times.AtLeastOnce());
this.EnqueueTestComplete();
});
}
public void TestLog()
{
var loggerFactory = IoCFactory.Resolve <ILoggerFactory>();
var logger = loggerFactory.Create(nameof(Log4NetLoggerTests));
var message = "test log level";
WriteLine(logger.Level);
LogTest(logger, message);
logger.ChangeLogLevel(Level.Debug);
Console.WriteLine(logger.Level);
LogTest(logger, message);
logger.ChangeLogLevel(Level.Info);
Console.WriteLine(logger.Level);
LogTest(logger, message);
logger.ChangeLogLevel(Level.Warn);
Console.WriteLine(logger.Level);
LogTest(logger, message);
logger.ChangeLogLevel(Level.Error);
Console.WriteLine(logger.Level);
LogTest(logger, message);
logger.ChangeLogLevel(Level.Fatal);
Console.WriteLine(logger.Level);
LogTest(logger, message);
}
/// <summary>Use Log4Net as the logger for the enode framework.
/// </summary>
/// <returns></returns>
public static Configuration UseUnityContainer(this Configuration configuration, IUnityContainer unityContainer = null)
{
if (IoCFactory.IsInit())
{
return(configuration);
}
if (unityContainer == null)
{
unityContainer = new UnityContainer();
try
{
unityContainer.LoadConfiguration();
}
catch (Exception ex)
{
Console.WriteLine(ex.GetBaseException().Message);
}
}
#region register lifetimemanager
unityContainer.RegisterType <LifetimeManager, ContainerControlledLifetimeManager>(configuration.GetLifetimeManagerKey(Lifetime.Singleton));
unityContainer.RegisterType <LifetimeManager, HierarchicalLifetimeManager>(configuration.GetLifetimeManagerKey(Lifetime.Hierarchical));
unityContainer.RegisterType <LifetimeManager, TransientLifetimeManager>(configuration.GetLifetimeManagerKey(Lifetime.Transient));
#endregion
var container = new ObjectContainer(unityContainer);
IoCFactory.SetContainer(container);
return(configuration);
}
protected override void ConsumeMessage(IFramework.MessageQueue.EQueue.MessageFormat.MessageContext eventContext, EQueueProtocols.QueueMessage queueMessage)
{
_Logger.DebugFormat("Start Handle event , messageContextID:{0} queueID:{1}", eventContext.MessageID, queueMessage.QueueId);
var message = eventContext.Message;
var messageHandlerTypes = HandlerProvider.GetHandlerTypes(message.GetType());
if (messageHandlerTypes.Count == 0)
{
return;
}
messageHandlerTypes.ForEach(messageHandlerType =>
{
PerMessageContextLifetimeManager.CurrentMessageContext = eventContext;
eventContext.ToBeSentMessageContexts.Clear();
var messageStore = IoCFactory.Resolve <IMessageStore>();
var subscriptionName = string.Format("{0}.{1}", SubscribeTopic, messageHandlerType.FullName);
if (!messageStore.HasEventHandled(eventContext.MessageID, subscriptionName))
{
try
{
var messageHandler = IoCFactory.Resolve(messageHandlerType);
((dynamic)messageHandler).Handle((dynamic)message);
var commandContexts = eventContext.ToBeSentMessageContexts;
var eventBus = IoCFactory.Resolve <IEventBus>();
var messageContexts = new List <MessageContext>();
eventBus.GetMessages().ForEach(msg => messageContexts.Add(new MessageContext(msg)));
messageStore.SaveEvent(eventContext, subscriptionName, commandContexts, messageContexts);
if (commandContexts.Count > 0)
{
IoCFactory.Resolve <ICommandBus>().Send(commandContexts.AsEnumerable());
}
if (messageContexts.Count > 0)
{
IoCFactory.Resolve <IEventPublisher>().Publish(messageContexts.ToArray());
}
}
catch (Exception e)
{
if (e is DomainException)
{
_Logger.Warn(message.ToJson(), e);
}
else
{
//IO error or sytem Crash
_Logger.Error(message.ToJson(), e);
}
messageStore.SaveFailHandledEvent(eventContext, subscriptionName, e);
}
finally
{
PerMessageContextLifetimeManager.CurrentMessageContext = null;
MessageCount++;
}
}
});
}
public MessageSender(IMessageQueueClient messageQueueClient, string defaultTopic = null)
{
_messageQueueClient = messageQueueClient;
_defaultTopic = defaultTopic;
_needMessageStore = Configuration.Instance.NeedMessageStore;
_messageStateQueue = new BlockingCollection <MessageState>();
_logger = IoCFactory.IsInit() ? IoCFactory.Resolve <ILoggerFactory>().Create(GetType().Name) : null;
}
public void GetInstanceOfNonRegisteredAndNonAbstractClassReturnsAlwaysANewInstance()
{
var adapter = new ServiceLocatorAdapter(IoCFactory.CreateServiceLocator());
var nonAbstractClassInstance1 = adapter.GetInstance <FooNonAbstractClass>();
var nonAbstractClassInstance2 = adapter.GetInstance <FooNonAbstractClass>();
Assert.AreNotSame(nonAbstractClassInstance1, nonAbstractClassInstance2);
}
public void GetAllInstanceJustReturnsCollectionOfWithOnylOneResolvedInstanceOfNonRegisteredNonAbstractClasses()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var serviceLocatorAdapter = new ServiceLocatorAdapter(serviceLocator);
FooNonAbstractClass[] list = serviceLocatorAdapter.GetAllInstances <FooNonAbstractClass>().ToArray();
Assert.AreEqual(1, list.Length);
}
public void GetAllInstanceJustReturnsEmptyCollectionIfTheTypeIsNonRegistered()
{
var serviceLocator = IoCFactory.CreateServiceLocator();
var serviceLocatorAdapter = new ServiceLocatorAdapter(serviceLocator);
IFooInterface[] list = serviceLocatorAdapter.GetAllInstances <IFooInterface>().ToArray();
Assert.AreEqual(0, list.Length);
}
public SlidingDoor(Action <int, long> commitOffset, int partition, bool commitPerMessage = false)
{
_commitOffset = commitOffset;
_partition = partition;
_offsets = new SortedSet <long>();
_commitPerMessage = commitPerMessage;
_logger = IoCFactory.Resolve <ILoggerFactory>().Create(this.GetType().Name);
}
public CommandConsumer(IHandlerProvider handlerProvider, string receiveEndPoint)
: base(handlerProvider)
{
MessageQueue = new BlockingCollection <IMessageContext>();
ReceiveEndPoint = receiveEndPoint;
ReplySenders = new Dictionary <string, ZmqSocket>();
_Logger = IoCFactory.Resolve <ILoggerFactory>().Create(this.GetType());
}
