private KeyPair(FileInfo privateKey, FileInfo publicKey, FileInfo passPhrase)
{
this.PrivateKey = privateKey;
this.PublicKey = publicKey;
this.PassPhrase = passPhrase;
DomainEvents.Publish(new KeyPairGeneratedEvent(this.Id));
}
public void TestSubscribe()
{
//Define a message class to send
var msg = new Msg {
Content = MagicString
};
//subscribe you handlers
DomainEvents <Msg> .Subscribe(Handler);
//maby ways to send
DomainEvents <Msg> .Publish(msg);
DomainEvents.Publish(msg);
DomainEvents.Publish(msg, typeof(Msg));
Assert.AreEqual(counter, 3);
//unsubcribe when done as we are not using weakreferences internally
DomainEvents <Msg> .Unsubscribe(Handler);
DomainEvents.Publish(msg);
Assert.AreEqual(counter, 3);
}
public void OnSuccesfullSaveSwtichesToReadMode(CmdApplicationConfigurationViewModel sut)
{
sut.ToggleEdit.Execute(null);
Assert.True(sut.IsInEditMode);
DomainEvents.Publish(new ConfigurationSavedEvent(Guid.NewGuid()));
Assert.False(sut.IsInEditMode);
}
/// <summary>
/// get tocid by annotation ,and used for get TOC By TOCId;
/// </summary>
/// <param name="annotation"></param>
/// <returns></returns>
public int GetTOCIdByAnnotation(Annotation annotation)
{
DomainEvents.Publish(new PublicationOpeningEvent(annotation.BookId, false)).Wait();
var tocDetail = packageAccess.GetTOCDetailByDocId(GlobalAccess.Instance.CurrentPublication.DecryptedDbFullName, annotation.DocId);
return(tocDetail.ID);
}
private void DoSubmitVerify(string content)
{
if (CanSubmitVerify())
{
if (content == null)
{
this.VerifyStatus = AccountVerifyStatus.Submited;
}
var verify = new AccountVerify()
{
AccountId = this.ID,
CreateTime = DateTime.Now,
Content = content,
Status = this.VerifyStatus,
};
this.AccountVerifies.Add(verify);
DomainEvents.Publish(new SubmitVerifyEvent()
{
Account = this, AccountVerify = verify
});
}
else
{
throw new SubmitApplyException("当前不允许提交审核");
}
}
private Task PublishTagDeletedEvent(Guid tagId)
{
return(Task.Run(async() =>
{
await DomainEvents.Publish(new TagDeletedEvent(tagId, GlobalAccess.Instance.Email, GlobalAccess.Instance.ServiceCode));
}));
}
/// <summary>
/// Add new Annotation
/// </summary>
/// <param name="annotation"></param>
/// <returns></returns>
public async Task AddAnnotation(Annotation annotation)
{
await DomainEvents.Publish(new PublicationOpeningEvent(annotation.BookId, false));
annotation.UpdatedTime = DateTime.UtcNow;
annotation.Status = AnnotationStatusEnum.Created;
annotation.IsUpdated = false;
Annotations annotations = new Annotations();
annotations.Email = GlobalAccess.Instance.Email;
annotations.ServiceCode = GlobalAccess.Instance.ServiceCode;
annotations.DocumentID = annotation.DocId;
annotations.AnnotationType = (int)annotation.Type;
annotations.BookID = annotation.BookId;
annotations.AnnotationCode = annotation.AnnotationCode;
annotations.AnnotationContent = annotation.ToXmlString();
annotations.CreatedDate = DateTime.Now;
annotations.LastModifiedDate = DateTime.Now;
annotations.Status = (int)AnnotationStatusEnum.Created;
annotations.IsSynced = false;
annotations.NoteText = annotation.NoteText;
annotations.HighlightText = annotation.HighlightText;
annotationAccess.AddAnnotation(annotations);
}
public static async Task <bool> RestFullPingServiceRequest(Uri uri, string uriTemplate, CancellationToken cancellationToken)
{
try
{
var response = await pingHclient.GetAsync(new Uri(uri + uriTemplate), cancellationToken);
if (response != null)
{
if (response.StatusCode == HttpStatusCode.OK)
{
DomainEvents.Publish(new LastSyncedTimeChangedEvent()).WithNoWarning();
var status = await response.Content.ReadAsStringAsync();
var pingStatus = JsonConvert.DeserializeObject <PingStatus>(status);
return(pingStatus.Status);
}
}
}
catch (OperationCanceledException)
{//add cancel operation
if (cancellationToken.IsCancellationRequested)
{
cancellationToken.ThrowIfCancellationRequested();
}
}
catch (Exception ex)
{
Logger.Log("Unable to reach: " + uri + " Error: " + ex);
}
return(false);
}
public static async Task <HttpResponse> RestFullServiceJsonRequest(Uri uri, string uriTemplate, Object serviceRequest, CancellationToken token = default(CancellationToken))
{
HttpResponse httpresponse = new HttpResponse {
IsSuccess = false
};
JsonSerializerSettings microsoftDateFormatSettings = new JsonSerializerSettings
{
DateFormatHandling = DateFormatHandling.MicrosoftDateFormat
};
string strEncodeBody = JsonConvert.SerializeObject(serviceRequest, microsoftDateFormatSettings);
var response = await hclient.PostAsync(new Uri(uri + uriTemplate), new StringContent(strEncodeBody)
{
Headers =
{
ContentType = new MediaTypeHeaderValue(Constants.CONTENT_TYPEJSON)
}
}, token);
if (response != null)
{
httpresponse.IsSuccess = (response.StatusCode == HttpStatusCode.OK);
if (response.StatusCode != HttpStatusCode.OK)
{
Logger.Log("Response Error" + response.ReasonPhrase);
httpresponse.Content = response.ReasonPhrase;
}
else
{
httpresponse.Content = await response.Content.ReadAsStringAsync();
DomainEvents.Publish(new LastSyncedTimeChangedEvent()).WithNoWarning();
}
}
return(httpresponse);
}
public void DispatchEvents()
{
foreach (IDomainEvent @event in Events)
{
DomainEvents.Publish(@event);
}
ClearEvents();
}
public void DownVote(Guid contributorId)
{
var vote = new DownVote(contributorId);
Votes.Add(vote);
DomainEvents.Publish(new QuestionDownVoted(Id, GetVoteCount(), contributorId));
}
public void PublishAnotherEventDoesNotInvokeHandlersOfOtherEvents(
Mock <IEventHandler <TestEvent> > testHandler,
TestAnotherEvent anotherEventData)
{
DomainEvents.Subscribe(testHandler.Object);
DomainEvents.Publish(anotherEventData);
testHandler.Verify(a => a.Handle(It.IsAny <TestEvent>()), Times.Never());
}
public void PublishRaisesEventsToSubscriber(
Mock <IEventHandler <TestEvent> > testHandler,
TestEvent eventData)
{
DomainEvents.Subscribe(testHandler.Object);
DomainEvents.Publish(eventData);
testHandler.Verify(a => a.Handle(eventData), Times.Once());
}
public void PublishWithNoSubscribersDoesNotCallHandler(
Mock <IEventHandler <TestEvent> > testHandler,
TestEvent eventData)
{
DomainEvents.ClearAllSubscriptions();
DomainEvents.Publish(eventData);
testHandler.Verify(a => a.Handle(eventData), Times.Never());
}
public void ClearAllSubscriptionsDoesNotRaiseEventsToPreviouslySubscribedClients(
Mock <IEventHandler <TestEvent> > testHandler,
TestEvent eventData)
{
DomainEvents.Subscribe(testHandler.Object);
DomainEvents.ClearAllSubscriptions();
DomainEvents.Publish(eventData);
testHandler.Verify(a => a.Handle(eventData), Times.Never());
}
public void SubscribersRegisteredAfterClearingAllSubscriptionsGetsNotifiedOfEvents(
Mock <IEventHandler <TestEvent> > testHandler,
TestEvent eventData)
{
DomainEvents.ClearAllSubscriptions();
DomainEvents.Subscribe(testHandler.Object);
DomainEvents.Publish(eventData);
testHandler.Verify(a => a.Handle(eventData), Times.Once());
}
/// <summary>
/// Update a existing Annotation
/// </summary>
/// <param name="annotation"></param>
/// <returns></returns>
public async Task UpdateAnnotation(Annotation annotation)
{
await DomainEvents.Publish(new PublicationOpeningEvent(annotation.BookId, false));
annotation.UpdatedTime = DateTime.UtcNow;
annotation.Status = AnnotationStatusEnum.Updated;
annotation.IsUpdated = true;
annotationAccess.UpdateAnnotation(annotation.DocId, annotation.Type, AnnotationStatusEnum.Updated, annotation.ToXmlString(), DateTime.Now, false, annotation.AnnotationCode);
}
public int SaveToSqliteWithSynctags()
{
try
{
return(SaveToSqlite(this.Tags, GlobalAccess.Instance.Email, GlobalAccess.Instance.ServiceCode));
}
finally
{
DomainEvents.Publish(new SyncTagsEvent());
}
}
private async Task UpdateCurrentPublication(DlBook dlBook)
{
var isSamePublication = (GlobalAccess.Instance.CurrentPublication != null &&
GlobalAccess.Instance.CurrentPublication.DlBook.BookId == dlBook.BookId);
//update currentPublication infomation when current publication is the downloaded publication
if (isSamePublication)
{
await DomainEvents.Publish(new PublicationOpeningEvent(dlBook, true));
}
}
public async Task <List <PageItem> > GetPagesByTOCID(int bookId, int tocId)
{
await DomainEvents.Publish(new PublicationOpeningEvent(bookId, false));
var currentPublication = GlobalAccess.Instance.CurrentPublication;
if (currentPublication.HasPage)
{
return(currentPublication.Pages.Where(page => page.TOCID == tocId).ToList());
}
return(null);
}
public async Task <PageItem> GetFirstPageItem(int bookId, int tocId)
{
await DomainEvents.Publish(new PublicationOpeningEvent(bookId, false));
var currentPublication = GlobalAccess.Instance.CurrentPublication;
if (currentPublication.HasPage)
{
var pages = await GetPagesByTOCID(bookId, tocId);
return(pages.FirstOrDefault());
}
return(null);
}
public static void Dispatch <TCommand>(TCommand command) where TCommand : ICommand
{
var commandInterface = typeof(TCommand).GetInterfaces().FirstOrDefault(t => t.GetInterfaces().Any(t1 => t1 == typeof(ICommand)));
if (commandInterface == null)
{
CommandHandlerFactory.GetHandlerFor <TCommand>().Execute(command);
}
else
{
var cmd = CommandHandlerFactory.GetHandlerFor(commandInterface);
cmd.GetType().GetMethod("Execute").Invoke(cmd, new object[] { command });
}
DomainEvents.Publish();
}
public async Task <int> GetMaxPageNum(int bookId)
{
await DomainEvents.Publish(new PublicationOpeningEvent(bookId, false));
var currentPublication = GlobalAccess.Instance.CurrentPublication;
if (currentPublication.HasPage)
{
return(currentPublication.Pages.Max((o) => o.Identifier));
}
else
{
return(0);
}
}
public void AddComment(Comment comment)
{
const int requiredReputation = 1000;
if (comment.GetContributorReputation() < requiredReputation)
{
throw new InsufficientReputationException(
$@"The contributor '{comment.GetContributorId()}', does not have the required reputation to comment on the question '{Id}',
current reputation: {comment.GetContributorReputation()},
required reputation: {requiredReputation}");
}
Comments.Add(comment);
DomainEvents.Publish(new QuestionCommentAdded(Id, comment.Id, comment.GetContributorId()));
}
public void Decrypt(FileInfo fileToDecrypt, ICryptographyExecutionService cryptoCmdService)
{
CryptographyResponse response;
try
{
response = cryptoCmdService.Execute(new DecryptionRequest(fileToDecrypt, this.PublicKey, this.PassPhrase));
if (response == null || response.Files.Count() != 1)
{
throw new Exception();
}
}
catch (Exception e) { throw; }
DomainEvents.Publish(new FileDecryptedEvent(this.Id, response.Files.First()));
}
public void AddAnAnswer(Answer answer)
{
const int requiredReputation = 1000;
if (answer.GetContributorReputation() < requiredReputation)
{
throw new InsufficientReputationException(
$@"The contributor '{answer.GetContributorId()}', does not have the required reputation to add an answer to the question '{Id}',
current reputation: {answer.GetContributorReputation()},
required reputation: {requiredReputation}");
}
Answers.Add(answer);
DomainEvents.Publish <AnswerAdded>(new AnswerAdded(Id, answer.Id, answer.GetContributorId()));
}
public void PublishRaisesEventsToAllSubscribers(
IEnumerable <Mock <IEventHandler <TestEvent> > > testHandlers,
TestEvent eventData)
{
foreach (var testHandler in testHandlers)
{
DomainEvents.Subscribe(testHandler.Object);
}
DomainEvents.Publish(eventData);
foreach (var testHandler in testHandlers)
{
testHandler.Verify(a => a.Handle(eventData), Times.Once());
}
}
public void ResetPassword(int userId)
{
if (this.Status == AccountStatus.Froze || this.Status == AccountStatus.Loss)
{
throw new AccountFrozeException("竞买号已冻结或挂失，不允许重置密码");
}
if (this.Trade.CreatorId != userId)
{
throw new AccountFrozeException("挂牌人只能重置自己宗地的竞买号的密码");
}
this.Password = GeneratePassword();
this.PasswordUpdated = false;
DomainEvents.Publish(new ResetPasswordEvent()
{
Account = this
});
}
public void Add(T item)
{
Printer.Print(ConsoleColor.Yellow);
var aggregate = Cloner.DeepClone(item);
if (!Data.Events.ContainsKey(typeof(T)))
{
Data.Events.Add(typeof(T), new Dictionary <Guid, List <DomainEvent> >());
}
if (Data.Events[typeof(T)].ContainsKey(aggregate.Id))
{
if (aggregate.CommittedEvents.Count != Data.Events[typeof(T)][aggregate.Id].Count)
{
var missingEvents = Data.Events[typeof(T)][aggregate.Id].Where(e => !aggregate.CommittedEvents.Any(ae => e.EventId == ae.EventId)).ToList();
if (!aggregate.TryResolveConflicts(missingEvents))
{
var eventsMissed = string.Join(", ", missingEvents.Select(e => e.GetType().Name + " by: " + e.By + " at: " + e.At));
var uncommittedEvents = string.Join(", ", aggregate.UncommittedEvents.Select(e => e.GetType().Name));
throw new Exception("Concurrency Exception, missed the following events: " + eventsMissed + " conflicted with: " + uncommittedEvents);
}
else
{
var eventsMissed = string.Join(", ", missingEvents.Select(e => e.GetType().Name + " by: " + e.By + " at: " + e.At));
var uncommittedEvents = string.Join(", ", aggregate.UncommittedEvents.Select(e => e.GetType().Name));
Printer.Print("Concurrency Resolved Successfully for events: " + eventsMissed + " merged with: " + uncommittedEvents, ConsoleColor.Yellow);
}
}
Data.Events[typeof(T)][aggregate.Id].AddRange(aggregate.UncommittedEvents);
}
else
{
Data.Events[typeof(T)].Add(aggregate.Id, aggregate.UncommittedEvents);
}
item.CommittedEvents.AddRange(item.UncommittedEvents);
foreach (var uncommittedEvent in item.UncommittedEvents)
{
DomainEvents.Publish(uncommittedEvent);
}
item.UncommittedEvents.Clear();
}
public void AcceptAnswer(Guid answerId, Guid contributorId)
{
if (contributorId != Poster.Id)
{
throw new InvalidContributorException("Only the question poster may accept the answer");
}
var answer = Answers.FirstOrDefault(x => x.Id == answerId);
if (answer == null)
{
throw new InvalidAnswerException(Id, answerId);
}
answer.AcceptAnswer();
DomainEvents.Publish(new AnswerAccepted(Id, answerId));
}