protected override void Context()
{
EventPublisher publisher = new EventPublisher();
publisher.Publish(new EventData("1st"));
publisher.Publish(new EventData("2nd"));
eventData = publisher.GetMostRecentPublication<EventData>();
}
private static void Main(string[] args)
{
var testEventHappened = new TestEventHappened
{
Message = "Hello Eventing World!"
};
var eventPublisher = new EventPublisher<TestEventHappened>();
eventPublisher.Publish<object>(testEventHappened);
}
public void EventEnvelopeCannotBeNull()
{
var messageFactory = new Mock<ICreateMessages>();
var messageBus = new Mock<ISendMessages<EventEnvelope>>();
var publisher = new EventPublisher(messageFactory.Object, messageBus.Object);
var ex = Assert.Throws<ArgumentNullException>(() => publisher.Publish(HeaderCollection.Empty, null));
Assert.Equal("payload", ex.ParamName);
}
protected override void Context()
{
_handler = MockRepository.GenerateMock<IEventHandler<EventData>>();
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.RegisterHandler(_handler);
eventPublisher.UnregisterHandler(_handler);
eventPublisher.Publish(new EventData("My Event Data"));
}
// ReSharper disable InconsistentNaming
public void EventPublisherPublish_UnitTest_RegisteredType_FindsSubjectAndInvokesOnNext()
// ReSharper restore InconsistentNaming
{
var memo = new DesignValidationMemo();
var publisher = new EventPublisher();
var subscription = publisher.GetEvent<DesignValidationMemo>().Subscribe(m => Assert.AreSame(memo, m));
publisher.Publish(memo);
subscription.Dispose();
}
public void HeadersCanBeNull()
{
var messageFactory = new Mock<ICreateMessages>();
var messageBus = new Mock<ISendMessages<EventEnvelope>>();
var publisher = new EventPublisher(messageFactory.Object, messageBus.Object);
publisher.Publish(null, EventEnvelope.Empty);
messageFactory.Verify(mock => mock.Create(null, EventEnvelope.Empty), Times.Once);
messageBus.Verify(mock => mock.Send(It.IsAny<Message<EventEnvelope>>()), Times.Once);
}
protected override void Context()
{
_handler = MockRepository.GenerateMock<IEventHandler<EventData>>();
_handler.Stub(h => h.Handle(null)).IgnoreArguments().Callback(delegate(EventData data)
{
_eventData = data.SomeData;
return true;
});
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.RegisterHandler(_handler);
eventPublisher.Publish(new EventData("My Event Data"));
}
protected override void Context()
{
_handler = SetupHandlerToThrowException();
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.OnHandlerError(ex =>
{
handlerExecuted = true;
caughtException = ex;
});
eventPublisher.RegisterHandler(_handler);
eventPublisher.Publish(new EventData());
}
public void ResourceModel_Environment_DesignValidationService_WiredUp()
{
var eventPublisher = new EventPublisher();
var environmentID = Guid.NewGuid();
var environment = new Mock <IServer>();
environment.Setup(e => e.EnvironmentID).Returns(environmentID);
environment.Setup(e => e.Connection.ServerEvents).Returns(eventPublisher);
var instanceID = Guid.NewGuid();
var model = new ResourceModel(environment.Object, new Mock <IEventAggregator>().Object);
var errors = model.GetErrors(instanceID);
Assert.AreEqual(0, errors.Count);
var err = new ErrorInfo
{
InstanceID = instanceID,
};
var memo = new DesignValidationMemo
{
InstanceID = environmentID,
Errors = new List <IErrorInfo>
{
err
}
};
//------------Execute Test---------------------------
eventPublisher.Publish(memo);
//------------Assert Results-------------------------
errors = model.GetErrors(instanceID);
Assert.AreEqual(1, errors.Count);
Assert.AreSame(err, errors[0]);
}
/// <summary>
/// 仅仅更新状态，不做任何检查，主要是为外部系统提供服务
/// </summary>
/// <param name="sysNo"></param>
/// <param name="targetStatus"></param>
public virtual void UpdateStatus(int?sysNo, ComboStatus targetStatus)
{
TransactionScopeFactory.TransactionAction(() =>
{
_da.UpdateStatus(sysNo, targetStatus);
//更新活动状态
//ObjectFactory<ComboPromotionEngine>.Instance.UpdateComboActivityStatus(sysNo.Value, targetStatus);
// 发送待办消息
switch (targetStatus)
{
// 待审核
case ComboStatus.WaitingAudit:
EventPublisher.Publish <ComboSaleSubmitMessage>(new ComboSaleSubmitMessage
{
ComboSaleSysNo = sysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
break;
// 有效
case ComboStatus.Active:
EventPublisher.Publish <ComboSaleActiveMessage>(new ComboSaleActiveMessage
{
ComboSaleSysNo = sysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
break;
// 无效
case ComboStatus.Deactive:
EventPublisher.Publish <ComboSaleAuditRefuseMessage>(new ComboSaleAuditRefuseMessage
{
ComboSaleSysNo = sysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
break;
}
});
}
public void EnvironmentTreeViewModel_PermissionsChanged_MemoIDEqualsEnvironmentServerId_UserPermissionChanges()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
//var connectionServerId = Guid.NewGuid();
var memoServerID = Guid.NewGuid();
var pubMemo = new PermissionsModifiedMemo {
ServerID = memoServerID
};
pubMemo.ModifiedPermissions.Add(new WindowsGroupPermission {
ResourceID = resourceID, Permissions = Permissions.Execute
});
pubMemo.ModifiedPermissions.Add(new WindowsGroupPermission {
ResourceID = resourceID, Permissions = Permissions.DeployTo
});
var eventPublisher = new EventPublisher();
var connection = new Mock <IEnvironmentConnection>();
connection.Setup(e => e.ServerEvents).Returns(eventPublisher);
connection.SetupGet(c => c.ServerID).Returns(memoServerID);
var srepo = new Mock <IStudioResourceRepository>();
var repo = new Mock <IResourceRepository>();
#pragma warning disable 168
var environment = new EnvironmentModel(Guid.NewGuid(), connection.Object, repo.Object, srepo.Object)
{
Name = "localhost"
};
#pragma warning restore 168
connection.Setup(a => a.DisplayName).Returns("localhost");
//------------Execute Test---------------------------
eventPublisher.Publish(pubMemo);
srepo.Verify(a => a.UpdateRootAndFoldersPermissions(It.IsAny <Permissions>(), It.IsAny <Guid>(), true), Times.Never());
}
public virtual void Delete(string[] ids)
{
var orders = GetByIds(ids, CustomerOrderResponseGroup.Full.ToString());
using (var repository = RepositoryFactory())
{
//Raise domain events before deletion
var changedEntries = orders.Select(x => new GenericChangedEntry <CustomerOrder>(x, EntryState.Deleted));
EventPublisher.Publish(new OrderChangeEvent(changedEntries));
repository.RemoveOrdersByIds(ids);
foreach (var order in orders)
{
DynamicPropertyService.DeleteDynamicPropertyValues(order);
}
repository.UnitOfWork.Commit();
//Raise domain events after deletion
EventPublisher.Publish(new OrderChangedEvent(changedEntries));
}
}
protected override void Context()
{
_handler1 = MockRepository.GenerateMock <IEventHandler <EventData> >();
_handler1.Stub(h => h.Handle(null)).IgnoreArguments().Callback(delegate(EventData data)
{
_eventData1 = data.SomeData;
return(true);
});
_handler2 = MockRepository.GenerateMock <IEventHandler <EventData> >();
_handler2.Stub(h => h.Handle(null)).IgnoreArguments().Callback(delegate(EventData data)
{
_eventData2 = data.SomeData;
return(true);
});
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.RegisterHandler(_handler1);
eventPublisher.RegisterHandler(_handler2);
eventPublisher.Publish(new EventData("My Event Data"));
}
public void ReceivingMessagesIsResumed(string firstName, string lastName, string email, string phone)
{
// Arrange
using var busContext = new RabbitMqContextBuilder()
.WithExchange("TestExchange")
.WithConnectionString("amqp://*****:*****@localhost")
.CreateContext();
using var host = new MicroserviceHostBuilder()
.WithBusContext(busContext)
.AddEventListener <PersonEventListener>()
.CreateHost();
host.Start();
var publisher = new EventPublisher(busContext);
var personEvent = new PersonAddedEvent {
Person = new Person
{
FirstName = firstName,
LastName = lastName,
Email = email,
PhoneNumber = phone
}
};
// Act
host.Pause();
publisher.Publish(personEvent);
Thread.Sleep(WaitTime);
host.Resume();
Thread.Sleep(WaitTime);
// Assert
Assert.AreEqual(personEvent, PersonEventListener.ResultEvent);
}
public virtual async Task DeleteAsync(IEnumerable <string> ids)
{
using (var repository = RepositoryFactory())
{
var changedEntries = new List <GenericChangedEntry <FulfillmentCenter> >();
var dbCenters = await repository.GetFulfillmentCentersAsync(ids);
foreach (var dbCenter in dbCenters)
{
repository.Remove(dbCenter);
changedEntries.Add(new GenericChangedEntry <FulfillmentCenter>(dbCenter.ToModel(AbstractTypeFactory <FulfillmentCenter> .TryCreateInstance()), EntryState.Deleted));
}
await EventPublisher.Publish(new FulfillmentCenterChangingEvent(changedEntries));
await repository.UnitOfWork.CommitAsync();
await EventPublisher.Publish(new FulfillmentCenterChangedEvent(changedEntries));
FulfillmentCenterCacheRegion.ExpireRegion();
}
}
protected override void Save(IServer server, dynamic jsonObj)
{
try
{
string resName = jsonObj.resourceName;
string resCat = HelperUtils.SanitizePath((string)jsonObj.resourcePath, resName);
if (_resourceModel != null)
{
EventPublisher.Publish(new SaveUnsavedWorkflowMessage(_resourceModel, resName, resCat, AddToTabManager));
}
Close();
}
catch (Exception e)
{
Exception e1 = new Exception("There was a problem saving. Please try again.", e);
Dev2Logger.Info(e.Message + Environment.NewLine + " Stacktrace : " + e.StackTrace + Environment.NewLine + " jsonObj: " + jsonObj.ToString());
throw e1;
}
}
public void OnSave()
{
bool successfulSave;
try
{
using (var tx = Session.BeginTransaction())
{
// this isn't strictly necessary, NHibernate will
// automatically do it for us, but it make things
// more explicit
Session.Update(Model.Action);
tx.Commit();
}
successfulSave = true;
}
catch (StaleObjectStateException)
{
var mergeResult = Presenters.ShowDialog <MergeResult?>("Merge", Model.Action);
successfulSave = mergeResult != null;
ReplaceSessionAfterError();
}
// we call ActionUpdated anyway, either we updated the value ourselves
// or we encountered a concurrency conflict, in which case we _still_
// want other parts of the application to update themselves with the values
// from the db
EventPublisher.Publish(new ActionUpdated
{
Id = Model.Action.Id
}, this);
if (successfulSave)
{
View.Close();
}
}
public async Task EventPublisherShouldCallHandleOnEventHandlerWhenEventIsPublished()
{
//Arrange
var logger = new Mock <ILogger>();
var e = new EmployeeAddedEvent(
new Employee(new Company(1, ""), 1, "", "", ""), DateTime.Now);
var t = new List <Trucking.Business.Providers.Integration>();
var kt = new Mock <TestEventHandler>();
t.Add(kt.Object);
var service = new Mock <ISubscriptionService>();
service.Setup(f => f.GetSubscriptions <EmployeeAddedEvent>(e))
.Returns(Task.FromResult(t.Cast <IHandle <EmployeeAddedEvent> >()));
var publisher = new EventPublisher(logger.Object, service.Object);
//Act
await publisher.Publish(e);
//Assert
kt.Verify(f => f.Handle(e), Times.Once);
}
public static void PublishException(Exception e, bool inDockerContainer = true)
{
string eventBusHost;
int eventBusPort;
if (inDockerContainer)
{
eventBusHost = "rabbitmq";
eventBusPort = 5672;
}
else
{
eventBusHost = "localhost";
eventBusPort = 5673;
}
var config = new EventBusConfig()
{
Host = eventBusHost,
Port = eventBusPort,
QueueName = "jomaya.exception.publisher",
ExchangeName = "my-bus"
};
var myEvent = new ExceptionThrownEvent()
{
ExceptionType = e.GetType(),
GUID = Guid.NewGuid().ToString(),
Message = e.Message,
RoutingKey = "jomaya.exception.exceptionthrownevent",
StackTrace = e.StackTrace,
TimeStamp = DateTime.Now
};
using (var publisher = new EventPublisher(config))
{
publisher.Publish(myEvent);
}
}
/// <summary>
/// Publishes the provided <paramref name="events"/> on the event bus.
/// </summary>
public virtual void Publish <TEvent>(IEnumerable <TEvent> events)
where TEvent : IEvent <TAuthenticationToken>
{
events = events.ToList();
foreach (TEvent @event in events)
{
IEnumerable <RouteHandlerDelegate> handlers;
if (!PrepareAndValidateEvent(@event, "Akka", out handlers))
{
return;
}
// This could be null if Akka won't handle the command and something else will.
foreach (RouteHandlerDelegate eventHandler in handlers)
{
eventHandler.Delegate(@event);
}
}
// Let everything else know about the event
EventPublisher.Publish(events);
}
/// <summary>
/// 代收结算单 - 结算
/// </summary>
/// <param name="info"></param>
/// <returns></returns>
public GatherSettlementInfo SettleGatherSettlement(GatherSettlementInfo info)
{
info.SettleStatus = GatherSettleStatus.SET;
GatherSettlementInfo oldSettle = GatherSettlementDA.GetVendorSettleGatherInfo(info);
if (oldSettle.SettleStatus != GatherSettleStatus.AUD)
{
//该结算单不是已审核状态，不能进行结算操作！
throw new BizException(GetMessageString("Gather_Audited_Invalid_Settle"));
}
GatherSettlementDA.UpdateGatherSettlementSettleStatus(info);
//调用Invoice接口，创建PayItem:
ExternalDomainBroker.CreatePayItem(
new PayItemInfo()
{
OrderSysNo = info.SysNo.Value,
PayAmt = info.TotalAmt,
OrderType = PayableOrderType.CollectionSettlement,
PayStyle = PayItemStyle.Normal
});
//发送结算Message
EventPublisher.Publish(new GatherSettlementSettledMessage()
{
SettlementSysNo = info.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
//写Log:
//CommonService.WriteLog<VendorSettleGatherEntity>(entity, " Settle Gather ", entity.SysNo.Value.ToString(), (int)LogType.Purchase_Verify_InStock);
ExternalDomainBroker.CreateLog(" Settle Gather "
, BizEntity.Common.BizLogType.Purchase_Verify_InStock
, info.SysNo.Value
, info.CompanyCode);
return(info);
}
public void SendMessageToWMS(SOInfo soInfo, WMSAction action, OPCCallBackType callBackType)
{
object mark = new object();
List <int> stockSysNoList = (from item in soInfo.Items
where item.StockSysNo.HasValue && item.ProductType != SOProductType.Coupon && item.ProductType != SOProductType.ExtendWarranty
select item.StockSysNo.Value).Distinct().ToList();
lock (mark)
{
int masterID = this.SaveOPCMaster(soInfo, action, callBackType);
foreach (int stockSysNo in stockSysNoList)
{
WarehouseInfo wareInfo = ExternalDomainBroker.GetWarehouseInfo(stockSysNo);
string stockID = wareInfo == null ? "" : wareInfo.WarehouseID;
if (String.IsNullOrEmpty(stockID))
{
BizExceptionHelper.Throw("SO_Audit_StockIsNotExist", stockSysNo.ToString());
}
int transactionID = this.SaveOPCTransaction(soInfo.SysNo.Value, stockSysNo, masterID, soInfo.CompanyCode);
WMSSOActionRequestMessage requestEntity = new WMSSOActionRequestMessage
{
SOSysNo = soInfo.SysNo.Value,
CompanyCode = soInfo.CompanyCode,
ActionDate = DateTime.Now,
ActionReason = string.Format("{0} SO", action.ToDisplayText()),
StockSysNo = stockSysNo,
TransactionSysNo = transactionID,
StockID = stockID,
Language = soInfo.BaseInfo.LanguageCode,
ActionType = WMSActionToAction(action),
ActionUser = ServiceContext.Current.UserSysNo
};
this.SaveOPCMessage(soInfo, transactionID, requestEntity);
EventPublisher.Publish <WMSSOActionRequestMessage>(requestEntity);
}
}
}
/// <summary>
/// 审核
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public CollectionPaymentInfo Audit(CollectionPaymentInfo entity)
{
string OperationIP = entity.OperationIP;
int? OperationUserSysNumber = entity.OperationUserSysNumber;
string OperationUserUniqueName = entity.OperationUserUniqueName;
entity.AuditUserSysNo = entity.CurrentUserSysNo;
//entity.AuditUserSysNo = SystemUserHelper.GetUserSystemNumber(BusinessContext.Current.OperationUserFullName,
// BusinessContext.Current.OperationUserSourceDirectoryKey, BusinessContext.Current.OperationUserLoginName,
// BusinessContext.Current.CompanyCode);
//entity.AuditUserSysNo = 3256;
VerifyAudite(entity);
VerifyProductPMSysNo(entity);
entity.AuditTime = DateTime.Now;
entity.Status = POCollectionPaymentSettleStatus.Audited;
entity = CollectionPaymentDA.UpdateVendorSettleStatus(entity);
//发送ESB消息
EventPublisher.Publish <CollectionPaymentAuditMessage>(new CollectionPaymentAuditMessage()
{
CurrentUserSysNo = ServiceContext.Current.UserSysNo,
SysNo = entity.SysNo.Value
});
entity.OperationIP = OperationIP;
entity.OperationUserSysNumber = OperationUserSysNumber;
entity.OperationUserUniqueName = OperationUserUniqueName;
//CommonService.WriteLog<CollectionPaymentEntity>(entity, " Audit CollectionPayment ", entity.SysNo.Value.ToString(), (int)LogType.CollectionPayment_Audit);
ExternalDomainBroker.CreateLog(" Audit CollectionPayment "
, BizEntity.Common.BizLogType.POC_VendorSettle_Audit
, entity.SysNo.Value
, entity.CompanyCode);
return(entity);
}
/// <summary>
/// 厂商回复的批量发布与拒绝
/// </summary>
/// <param name="item"></param>
public virtual void UpdateProductReviewVendorReplyStatus(ProductReviewReply item)
{
TransactionScopeFactory.TransactionAction(() =>
{
int x = productReviewDA.UpdateProductReviewVendorReplyStatus(item);
switch (item.Status)
{
//发布
case "A":
EventPublisher.Publish <ProductReviewReplyAuditMessage>(new ProductReviewReplyAuditMessage
{
SysNo = item.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
break;
//拒绝
case "D":
EventPublisher.Publish <ProductReviewReplyVoidMessage>(new ProductReviewReplyVoidMessage
{
SysNo = item.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
break;
}
if (x == 1001)
{
throw new BizException(ResouceManager.GetMessageString("MKT.Comment", "Comment_VendorWithdrawData"));
}
else if (x == 1002)
{
throw new BizException(ResouceManager.GetMessageString("MKT.Comment", "Comment_SubmitFailed"));
}
});
}
public void RemoveUnusedDataListItems()
{
var unusedScalars = ScalarCollection.Where(c => c.IsUsed == false).ToList();
if (unusedScalars.Any())
{
foreach (var dataListItemModel in unusedScalars)
{
ScalarCollection.Remove(dataListItemModel);
}
}
var unusedRecordsets = RecsetCollection.Where(c => c.IsUsed == false).ToList();
if (unusedRecordsets.Any())
{
foreach (var dataListItemModel in unusedRecordsets)
{
RecsetCollection.Remove(dataListItemModel);
}
}
foreach (var recset in RecsetCollection)
{
if (recset.Children.Count > 0)
{
var unusedRecsetChildren = recset.Children.Where(c => c.IsUsed == false).ToList();
if (unusedRecsetChildren.Any())
{
foreach (var unusedRecsetChild in unusedRecsetChildren)
{
recset.Children.Remove(unusedRecsetChild);
}
}
}
}
WriteToResourceModel();
EventPublisher.Publish(new UpdateIntellisenseMessage());
}
/// <summary>
/// 根据订单编号作废netpay
/// </summary>
/// <param name="soSysNo"></param>
public virtual void AbandonBySOSysNo(int soSysNo)
{
NetPayInfo netpayInfo = GetValidBySOSysNo(soSysNo);
if (netpayInfo != null)
{
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = IsolationLevel.ReadUncommitted;
options.Timeout = TimeSpan.FromMinutes(2);
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, options))
{
m_NetpayDA.AbandonBySOSysNo(soSysNo);
//发送netpay作废Message
EventPublisher.Publish <NetpayAbandonedMessage>(new NetpayAbandonedMessage()
{
NetpaySysNo = netpayInfo.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
ts.Complete();
}
}
}
void ChangeStatus(ListenerStatus newStatus)
{
lock (syncLock)
{
if (Status == newStatus)
{
return;
}
else if ((newStatus == ListenerStatus.Paused || newStatus == ListenerStatus.Stopped) && Status != ListenerStatus.Running)
{
throw new InvalidOperationException("Listener is not running");
}
Status = newStatus;
EventPublisher.Publish(new StatusChangedEvent()
{
NewStatus = Status
});
Debug.WriteLine("Listener status is '{0}'", Status);
}
}
public void DefaultingDispatcherDeserializesCorrectly()
{
using (var publisher = new EventPublisher())
using (var target = new DefaultingDispatcherMock())
{
target.Open();
var evt = new AnotherEvent()
{
SomeValue = 7
};
publisher.Publish(evt);
Thread.Sleep(100);
Assert.Equal(true, target.DefaultHandlerHasBeenCalled);
Assert.Equal(7, target.DefaultHandlerObject.Value <int>("SomeValue"));
Assert.Equal("Dummy.AnotherEvent", target.DefaultHandlerObject.Value <string>("RoutingKey"));
Assert.Equal(evt.Timestamp, target.DefaultHandlerObject.Value <long>("Timestamp"));
Assert.Equal("InfoSupport.WSA.Infrastructure.Test.dummies.AnotherEvent", target.DefaultHandlerObject.Value <string>("TypeName"));
}
}
public virtual void CategoryRequestCanel(CategoryRequestApprovalInfo info)
{
// if (categoryRequestApprovalDA.CheckCategoryUser(info.SysNo))
//{
// throw new BizException("审核人和创建人不能是同一个人!");
//}
info.Status = CategoryAuditStatus.CategoryAuditCanel;
using (TransactionScope scope = new TransactionScope())
{
categoryRequestApprovalDA.ActiveCategoryRequest(info);
//取消审核之后发送消息
EventPublisher.Publish <CategoryCancelMessage>(new CategoryCancelMessage()
{
CancelUserSysNo = ServiceContext.Current.UserSysNo,
RequestSysNo = info != null && info.SysNo.HasValue ? info.SysNo.Value : 0,
CategorySysNo = info != null ? info.CategorySysNo : 0
});
scope.Complete();
}
}
public async virtual Task AfterCreate(IEnumerable <E> objects)
{
// Feed the event service bus the DB trigger
try
{
if (EventPublisher != null)
{
await EventPublisher.Publish(GetEventName(OnCreateFormattedString), objects);
}
}
catch (Exception e)
{
// TODO: implement a logging service for processing these requests (IPlatformLogger)
throw e;
}
// Notify event subscribers of event
try
{
if (EventSubscriberFactory != null)
{
var subscribers = await EventSubscriberFactory.GetSubscribers(GetEventName(OnCreateFormattedString));
foreach (var subscriber in subscribers)
{
await EventSubscriberFactory.Execute(subscriber);
}
}
}
catch (Exception e)
{
// TODO: implement a logging service for processing these requests (IPlatformLogger)
throw e;
}
}
public Round StartGame(StartGameCommand command)
{
Dealer dealer = new Dealer();
Round round = new Round()
{
Dealer = dealer,
Player = new Player()
{
Hand = new PlayerHand()
{
CardsInHand = new List <Card>()
{
dealer.Hit(), dealer.Hit()
}
}
},
};
GameStartedEvent gse = new GameStartedEvent()
{
round = round, RoutingKey = "blabla", GUID = Guid.NewGuid().ToString(), TimeStamp = DateTime.UtcNow
};
// Publish event
using (var eventPublishService =
new EventPublisher(
new EventBusConfig()
{
QueueName = "web-app-listener-queue",
Host = "localhost"
})
)
{
eventPublishService.Publish(gse);
}
return(round);
}
public void EventListenerIsCalledWithCorrectEvent()
{
var serviceMock = new Mock <IServiceMock>(MockBehavior.Strict);
serviceMock.Setup(d => d.PerformAction());
using (var context = new TestBusContext())
{
var builder = new MicroserviceHostBuilder()
.RegisterDependencies((services) =>
{
services.AddSingleton(serviceMock.Object);
})
.WithContext(context)
.UseConventions();
using (var host = builder.CreateHost())
{
host.StartListening();
var eventPublisher = new EventPublisher(context);
var exampleEvent = new ExampleEvent("XMPL.ExampleEvent")
{
Message = "Example message."
};
eventPublisher.Publish(exampleEvent);
}
var eventListenerIsCalled = EventListenerMock.ResetEvent.WaitOne(1000);
Assert.IsTrue(eventListenerIsCalled);
var actualEvent = EventListenerMock.ExampleEvent;
Assert.AreEqual("XMPL.ExampleEvent", actualEvent.RoutingKey);
Assert.AreEqual("Example message.", actualEvent.Message);
serviceMock.VerifyAll();
}
}
/// <summary>
/// 创建顾客余额退款信息
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual BalanceRefundInfo Create(BalanceRefundInfo entity)
{
if (entity.ReturnPrepayAmt <= 0)
{
//throw new BizException("退款金额必须大于等于0。");
ThrowBizException("BalanceRefund_RefundAmoutNeedMoreThan0");
}
if (!ExternalDomainBroker.ExistsCustomer(entity.CustomerSysNo.Value))
{
//throw new BizException(string.Format("编号为{0}的顾客不存在。", entity.CustomerSysNo));
ThrowBizException("BalanceRefund_NotExsistCustomer", entity.CustomerSysNo);
}
TransactionOptions options = new TransactionOptions();
options.IsolationLevel = IsolationLevel.ReadUncommitted;
using (TransactionScope ts = new TransactionScope(TransactionScopeOption.Required, options))
{
ExternalDomainBroker.AdjustCustomerPerpayAmount(entity.CustomerSysNo.Value, 0, -entity.ReturnPrepayAmt.Value, PrepayType.BalanceReturn, "余额账户转银行退款");
entity.Status = BalanceRefundStatus.Origin;
entity = m_BalanceRefundDA.Create(entity);
//发送创建Message
EventPublisher.Publish(new CreateBalanceRefundMessage()
{
ReturnPrepaySysNo = entity.SysNo.Value,
CurrentUserSysNo = ServiceContext.Current.UserSysNo
});
ts.Complete();
}
return(entity);
}
public virtual async Task SaveChangesAsync(Store[] stores)
{
ValidateStoresProperties(stores);
using (var repository = RepositoryFactory())
{
var changedEntries = new List <GenericChangedEntry <Store> >();
var pkMap = new PrimaryKeyResolvingMap();
var dbStores = await repository.GetStoresByIdsAsync(stores.Select(x => x.Id).ToArray());
foreach (var store in stores)
{
var targetEntity = dbStores.FirstOrDefault(x => x.Id == store.Id);
var sourceEntity = AbstractTypeFactory <StoreEntity> .TryCreateInstance().FromModel(store, pkMap);
if (targetEntity != null)
{
changedEntries.Add(new GenericChangedEntry <Store>(store, targetEntity.ToModel(AbstractTypeFactory <Store> .TryCreateInstance()),
EntryState.Modified));
sourceEntity.Patch(targetEntity);
}
else
{
repository.Add(sourceEntity);
changedEntries.Add(new GenericChangedEntry <Store>(store, EntryState.Added));
}
await repository.UnitOfWork.CommitAsync();
pkMap.ResolvePrimaryKeys();
await EventPublisher.Publish(new StoreChangedEvent(changedEntries));
}
}
ClearCache(stores);
}
public void EventListenerDoesCallListenerOnInvalidJson(string body)
{
// Arrange
using var busContext = new RabbitMqContextBuilder()
.WithExchange("TestExchange")
.WithConnectionString("amqp://*****:*****@localhost")
.CreateContext();
using var host = new MicroserviceHostBuilder()
.WithBusContext(busContext)
.AddEventListener <PersonEventListener>()
.CreateHost();
host.Start();
EventPublisher publisher = new EventPublisher(busContext);
// Act
publisher.Publish(242424, "PeopleApp.Persons.New", Guid.NewGuid(), "PersonEvent", body);
Thread.Sleep(WaitTime);
// Assert
Assert.IsNull(PersonEventListener.ResultEvent);
}
/// <summary>
/// 作废代销商品规则
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual ConsignSettlementRulesInfo AbandonConsignSettlementRule(string settleRulesCode)
{
ConsignSettlementRulesInfo entity = ConsignSettlementRuleDA.GetConsignSettleRuleByCode(settleRulesCode);
if (entity == null)
{
//规则({0})不存在，无法作废
throw new BizException(string.Format(GetExceptionString("ConsignRule_RuleNotExist_Abandon"), settleRulesCode));
}
if (entity.Status != ConsignSettleRuleStatus.Wait_Audit)
{
//规则({0})不处于待审核状态，无法作废
throw new BizException(string.Format(GetExceptionString("ConsignRule_WaitingAudit_Invalid_Abandon"), settleRulesCode));
}
entity.Status = ConsignSettleRuleStatus.Forbid;
entity.EditUser = ExternalDomainBroker.GetUserNameByUserSysNo(ServiceContext.Current.UserSysNo);
entity = Modify(entity, ConsignSettleRuleActionType.Abandon);
//发送ESB消息
EventPublisher.Publish <SettlementRuleAbandonMessage>(new SettlementRuleAbandonMessage()
{
AbandonUserSysNo = ServiceContext.Current.UserSysNo,
SettleRulesCode = settleRulesCode
});
//记录系统日志
// WriteLog(entity, LogType.ConsignSettleRule_Abadon);
ExternalDomainBroker.CreateLog(" Abandon ConsignSettleRule "
, BizEntity.Common.BizLogType.ConsignSettleRule_Abadon
, entity.RuleSysNo.Value
, entity.CompanyCode);
return(entity);
}
protected override void Context()
{
try
{
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.Publish(new EventData("My Event Data"));
}
catch (Exception ex)
{
_caughtException = ex;
}
}
public void ResourceModel_Rollback_FixedErrorsRestored()
{
//Setup();
var eventPublisher = new EventPublisher();
var environmentModel = CreateMockEnvironment(eventPublisher);
var instanceID = Guid.NewGuid();
var model = new ResourceModel(environmentModel.Object)
{
ID = instanceID
};
var hitCount = 0;
model.OnDesignValidationReceived += (sender, memo) =>
{
switch (hitCount++)
{
case 0:
Assert.AreEqual(2, model.Errors.Count);
Assert.AreEqual(0, model.FixedErrors.Count);
break;
case 1:
Assert.AreEqual(1, model.Errors.Count);
Assert.AreEqual(1, model.FixedErrors.Count);
model.Rollback();
Assert.AreEqual(2, model.Errors.Count);
Assert.AreEqual(0, model.FixedErrors.Count);
break;
}
};
// Publish 2 errors
var pubMemo = new DesignValidationMemo { InstanceID = instanceID };
pubMemo.Errors.Add(new ErrorInfo { ErrorType = ErrorType.Critical, Message = "Critical error.", InstanceID = instanceID });
pubMemo.Errors.Add(new ErrorInfo { ErrorType = ErrorType.Warning, Message = "Warning error.", InstanceID = instanceID });
eventPublisher.Publish(pubMemo);
// Fix 1 error and publish
pubMemo.Errors.RemoveAt(1);
eventPublisher.Publish(pubMemo);
}
public void ResourceModel_Environment_DesignValidationService_WiredUp()
{
var eventPublisher = new EventPublisher();
var environmentID = Guid.NewGuid();
var environment = new Mock<IEnvironmentModel>();
environment.Setup(e => e.ID).Returns(environmentID);
environment.Setup(e => e.Connection.ServerEvents).Returns(eventPublisher);
var instanceID = Guid.NewGuid();
var model = new ResourceModel(environment.Object, new Mock<IEventAggregator>().Object);
var errors = model.GetErrors(instanceID);
Assert.AreEqual(0, errors.Count);
var err = new ErrorInfo
{
InstanceID = instanceID,
};
var memo = new DesignValidationMemo
{
InstanceID = environmentID,
Errors = new List<IErrorInfo>
{
err
}
};
//------------Execute Test---------------------------
eventPublisher.Publish(memo);
//------------Assert Results-------------------------
errors = model.GetErrors(instanceID);
Assert.AreEqual(1, errors.Count);
Assert.AreSame(err, errors[0]);
}
public void ResourceModel_DesignValidationServicePublishingMemo_UpdatesErrors()
{
//Setup();
var instanceID = Guid.NewGuid();
var pubMemo = new DesignValidationMemo { InstanceID = instanceID };
pubMemo.Errors.Add(new ErrorInfo { ErrorType = ErrorType.Critical, Message = "Critical error.", InstanceID = instanceID });
pubMemo.Errors.Add(new ErrorInfo { ErrorType = ErrorType.Warning, Message = "Warning error.", InstanceID = instanceID });
var eventPublisher = new EventPublisher();
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(e => e.ServerEvents).Returns(eventPublisher);
var environmentModel = new Mock<IEnvironmentModel>();
environmentModel.Setup(e => e.Connection).Returns(connection.Object);
var model = new ResourceModel(environmentModel.Object)
{
ID = instanceID
};
model.OnDesignValidationReceived += (sender, memo) =>
{
Assert.AreEqual(memo.Errors.Count, model.Errors.Count, "OnDesignValidationReceived did not update the number of errors correctly.");
foreach (var error in memo.Errors)
{
var modelError = model.Errors.FirstOrDefault(me => me.ErrorType == error.ErrorType && me.Message == error.Message);
Assert.AreSame(error, modelError, "OnDesignValidationReceived did not set the error.");
}
};
eventPublisher.Publish(pubMemo);
}
public void ResourceModel_DesignValidationServicePublishingMemo_NoInstanceID_DoesNotUpdatesErrors()
{
//Setup();
var instanceID = Guid.NewGuid();
var pubMemo = new DesignValidationMemo { InstanceID = instanceID };
pubMemo.Errors.Add(new ErrorInfo { ErrorType = ErrorType.Critical, Message = "Critical error." });
pubMemo.Errors.Add(new ErrorInfo { ErrorType = ErrorType.Warning, Message = "Warning error." });
var eventPublisher = new EventPublisher();
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(e => e.ServerEvents).Returns(eventPublisher);
var environmentModel = new Mock<IEnvironmentModel>();
environmentModel.Setup(e => e.Connection).Returns(connection.Object);
var model = new ResourceModel(environmentModel.Object)
{
ID = instanceID
};
model.OnDesignValidationReceived += (sender, memo) => Assert.AreEqual(0, model.Errors.Count, "OnDesignValidationReceived did not update the number of errors correctly.");
eventPublisher.Publish(pubMemo);
}
protected override void Context()
{
IEventPublisher eventPublisher = new EventPublisher();
_handler1 = MockRepository.GenerateMock<IEventHandler<EventData>>();
_handler1.Stub(h => h.Handle(null)).IgnoreArguments().Callback(delegate(EventData data)
{
eventPublisher.Publish(new SecondEvent());
return true;
});
_handler2 = MockRepository.GenerateMock<IEventHandler<SecondEvent>>();
_handler2.Stub(h => h.Handle(null)).IgnoreArguments().Callback(delegate(SecondEvent data)
{
_eventTwoWasHandled = true;
return true;
});
eventPublisher.RegisterHandler(_handler1);
eventPublisher.RegisterHandler(_handler2);
eventPublisher.Publish(new EventData("My Event Data"));
}
protected override void Context()
{
throwingHandler = SetupHandlerToThrowException();
catchingHandler = MockRepository.GenerateMock<IEventHandler<EventData>>();
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.RegisterHandler(throwingHandler);
eventPublisher.RegisterHandler(catchingHandler)
.WithErrorHandler(ex =>
{
caughtException = ex;
});
eventPublisher.Publish(new EventData());
}
public virtual ActionResult Edit(EntryRevision model)
{
model.AllTags = Repository.FindAll <Tag>();
if (!ModelState.IsValid)
{
model.SelectedTags = GetEditTags(model);
return(View(model));
}
var author = Authenticator.GetName();
var entry = Repository.Get <Entry>(model.Id);
if (entry == null && CurrentEntryExistsWithName(model.Name))
{
model.SelectedTags = GetEditTags(model);
ModelState.AddModelError("PageExists", string.Format("A page with SLUG '{0}' already exists. You should edit that page instead", model.Name));
return(View(model));
}
if (entry == null && CurrentEntryExistsWithName(model.Title) && model.Name == "")
{
model.SelectedTags = GetEditTags(model);
ModelState.AddModelError("PageExists", string.Format("A page with SLUG '{0}' already exists. Please add a unique SLUG here.", model.Title));
return(View(model));
}
entry = entry ?? new Entry {
Author = author
};
entry.Name = string.IsNullOrWhiteSpace(model.Name) ? model.Title.Slugify() : model.Name.ToString();
entry.PageTemplate = string.IsNullOrEmpty(model.PageTemplate) ? null : model.PageTemplate;
entry.Title = model.Title ?? string.Empty;
entry.Summary = model.Summary ?? string.Empty;
entry.MetaTitle = string.IsNullOrWhiteSpace(model.MetaTitle) ? model.Title : model.MetaTitle;
entry.IsDiscussionEnabled = !model.DisableComments;
entry.MetaDescription = model.MetaDescription ?? string.Empty;
entry.HideChrome = model.HideChrome;
//Only change the publish date if the dates no longer match, this means that
//time changes wont be tracked.
var published = DateTime.Parse(model.PublishDate + " " + DateTime.Now.ToShortTimeString(), CultureInfo.CurrentCulture).ToUniversalTime();
if (entry.Published.Date != published.Date)
{
entry.Published = published;
}
entry.Status = model.Status;
var revision = entry.Revise();
revision.Author = author;
revision.Body = model.Body;
revision.Reason = model.ChangeSummary ?? string.Empty;
revision.Format = model.Format;
var editTags = GetEditTags(model);
var toDelete = entry.Tags.Where(t => !editTags.Contains(t)).ToList();
var toAdd = editTags.Where(t => !entry.Tags.Contains(t)).ToList();
foreach (var tag in toDelete)
{
tag.Remove(entry);
}
foreach (var tag in toAdd)
{
if (tag.Id == 0)
{
Repository.Add(tag);
}
tag.Add(entry);
}
EventPublisher.Publish(new EntrySavedEvent(entry));
if (model.IsNew)
{
Repository.Add(entry);
}
return(RedirectToAction("Page", "Wiki", new { Area = "", page = entry.Name }));
}
public void ClientSecurityService_PermissionsModified_NewPermissionsReceived_ShouldReplaceCurrentPermissions()
{
//------------Setup for test--------------------------
var connection = new Mock<IEnvironmentConnection>();
IEventPublisher eventPublisher = new EventPublisher();
connection.Setup(c => c.ServerEvents).Returns(eventPublisher);
var clientSecurityService = new TestClientSecurityService(connection.Object);
var currentPermissions = new List<WindowsGroupPermission>();
Guid resourceID = Guid.NewGuid();
var resourcePermission = new WindowsGroupPermission();
resourcePermission.ResourceID = resourceID;
resourcePermission.Permissions = Permissions.View & Permissions.Execute;
var serverPermission = new WindowsGroupPermission();
serverPermission.ResourceID = Guid.Empty;
serverPermission.Permissions = Permissions.DeployFrom & Permissions.DeployTo;
serverPermission.IsServer = true;
currentPermissions.Add(serverPermission);
currentPermissions.Add(resourcePermission);
clientSecurityService.SetCurrentPermissions(currentPermissions);
clientSecurityService.ReadAsync().Wait();
var changedPermissions = new List<WindowsGroupPermission>();
var changedResourcePermission = new WindowsGroupPermission();
changedResourcePermission.ResourceID = resourceID;
changedResourcePermission.Permissions = Permissions.Contribute;
var changedServerPermission = new WindowsGroupPermission();
changedServerPermission.ResourceID = Guid.Empty;
changedServerPermission.Permissions = Permissions.Administrator;
changedServerPermission.IsServer = true;
changedPermissions.Add(changedServerPermission);
changedPermissions.Add(changedResourcePermission);
var permissionsModifiedMemo = new PermissionsModifiedMemo();
permissionsModifiedMemo.ModifiedPermissions = changedPermissions;
//------------Execute Test---------------------------
connection.Raise(environmentConnection => environmentConnection.PermissionsModified += null, null,changedPermissions);
eventPublisher.Publish(permissionsModifiedMemo);
//------------Assert Results-------------------------
var updateResourcePermission = clientSecurityService.Permissions.FirstOrDefault(permission => permission.ResourceID == resourceID);
var updateServerPermission = clientSecurityService.Permissions.FirstOrDefault(permission => permission.ResourceID == Guid.Empty);
Assert.IsNotNull(updateResourcePermission);
Assert.IsNotNull(updateServerPermission);
Assert.AreEqual(Permissions.Contribute, updateResourcePermission.Permissions);
Assert.AreEqual(Permissions.Administrator, updateServerPermission.Permissions);
}
// ReSharper disable InconsistentNaming
public void EventPublisherPublish_UnitTest_UnregisteredType_DoesNotFindSubject()
// ReSharper restore InconsistentNaming
{
var memo = new Memo();
var publisher = new EventPublisher();
publisher.Publish(memo);
Assert.IsTrue(true);
}
public void EnvironmentTreeViewModel_PermissionsChanged_MemoIDEqualsEnvironmentServerId_UserPermissionChangesNonLocalHost()
{
//------------Setup for test--------------------------
var resourceID = Guid.NewGuid();
//var connectionServerId = Guid.NewGuid();
var memoServerID = Guid.NewGuid();
var pubMemo = new PermissionsModifiedMemo { ServerID = memoServerID };
pubMemo.ModifiedPermissions.Add(new WindowsGroupPermission { ResourceID = resourceID, Permissions = Permissions.Execute });
pubMemo.ModifiedPermissions.Add(new WindowsGroupPermission { ResourceID = resourceID, Permissions = Permissions.DeployTo });
var eventPublisher = new EventPublisher();
var connection = new Mock<IEnvironmentConnection>();
connection.Setup(e => e.ServerEvents).Returns(eventPublisher);
connection.SetupGet(c => c.ServerID).Returns(memoServerID);
var srepo = new Mock<IStudioResourceRepository>();
var repo = new Mock<IResourceRepository>();
#pragma warning disable 168
var environment = new EnvironmentModel(Guid.NewGuid(), connection.Object, repo.Object, srepo.Object) { Name = "localhost" };
connection.Raise(environmentConnection => environmentConnection.NetworkStateChanged += null, new NetworkStateEventArgs(NetworkState.Offline, NetworkState.Online));
#pragma warning restore 168
connection.Setup(a => a.DisplayName).Returns("bob");
//------------Execute Test---------------------------
eventPublisher.Publish(pubMemo);
srepo.Verify(a => a.UpdateRootAndFoldersPermissions(It.IsAny<Permissions>(), It.IsAny<Guid>(), true), Times.Never());
}
protected override void Context()
{
_handler = SetupHandlerToThrowException();
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.RegisterHandler(_handler);
try
{
eventPublisher.Publish(new EventData());
}
catch(Exception ex)
{
caughtException = ex;
}
}
public void Accept()
{
_status = DocumentStatus.Accepted;
EventPublisher.Publish(new DocumentAccepted(Id));
}
protected override void Context()
{
handlerExecutedCount = 0;
_handler = SetupHandlerToThrowException();
_handler2 = SetupHandlerToThrowException();
IEventPublisher eventPublisher = new EventPublisher();
eventPublisher.OnHandlerError(ex =>
{
handlerExecutedCount += 1;
});
eventPublisher.RegisterHandler(_handler);
eventPublisher.RegisterHandler(_handler2);
eventPublisher.Publish(new EventData());
}
