///-------------------------------------------------------------------------------------------------
/// <summary>
/// Sends a message.
/// </summary>
/// <param name="originStoreId">
/// Identifier for the origin store.
/// </param>
/// <param name="mode">
/// The mode.
/// </param>
/// <param name="sessionId">
/// Identifier for the session.
/// </param>
/// <param name="events">
/// The events.
/// </param>
/// <returns>
/// A Message.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected override Message SendMessage(string originStoreId, ISessionInformation session, IEnumerable <IEvent> events)
{
EventQueue.Add(new InprocMessage {
Mode = session.Mode, OriginStoreId = originStoreId, Events = events.ToList()
});
return(null);
}
private void SendEvents(ISessionInformation session)
{
DebugContract.Requires(session);
if (_disposed || Filters == null)
{
return;
}
var origin = session.OriginStoreId;
//if (origin != Store.Id)
// return;
bool first = true;
List <IEvent> events = new List <IEvent>();
foreach (var evt in session.Events)
{
if (ShouldBePropagated(evt))
{
if (first)
{
Store.Trace.WriteTrace(TraceCategory.EventBus, "Send events on channel {0} Store {1}", this.GetType().Name, Store.Id);
}
first = false;
Store.Trace.WriteTrace(TraceCategory.EventBus, "Prepare event {0}", evt);
events.Add(evt);
}
}
if (events.Count > 0)
{
SendMessage(origin, session, events);
}
}
private void OnSesssionCompleted(ISessionInformation session)
{
DebugContract.Requires(session);
var originId = session.OriginStoreId;
if (session.IsAborted || !session.Events.Any() || _disposed || (originId != null && originId != Store.Id) || (session.Mode & SessionMode.Loading) == SessionMode.Loading || (session.Mode & SessionMode.LoadingSchema) == SessionMode.LoadingSchema)
{
return;
}
var elements = session.TrackingData.InvolvedTrackedElements.Where(e => String.Compare(e.DomainName, DomainModel.Name, StringComparison.OrdinalIgnoreCase) == 0 && String.Compare(e.Extension, DomainModel.ExtensionName, StringComparison.OrdinalIgnoreCase) == 0);
if (!elements.Any())
{
return;
}
var observer = this as IPersistenceGraphAdapter;
Debug.Assert(observer != null);
try
{
observer.PersistElements(session, elements);
}
catch (Exception ex)
{
session.Log(new DiagnosticMessage(MessageType.Error, ExceptionMessages.Diagnostic_ErrorInPersistenceAdapter, observer.GetType().FullName, null, ex));
}
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Sends a message.
/// </summary>
/// <param name="originStoreId">
/// Identifier for the origin store.
/// </param>
/// <param name="mode">
/// The mode.
/// </param>
/// <param name="sessionId">
/// Identifier for the session.
/// </param>
/// <param name="events">
/// The events.
/// </param>
/// <returns>
/// A Message.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected override Message SendMessage(string originStoreId, ISessionInformation session, IEnumerable <IEvent> events)
{
var msg = base.SendMessage(originStoreId, session, events);
Channel.ProcessEvents(msg);
return(msg);
}
private void OnChangedAttributeEvent(ISessionInformation session, ISessionContext log, ChangePropertyValueEvent cmd, Dictionary <Identity, IModelElement> notifications)
{
DebugContract.Requires(session);
DebugContract.Requires(log);
DebugContract.Requires(cmd);
if (!Equals(cmd.OldValue, cmd.Value))
{
var ctx = new EventContext <ChangePropertyValueEvent>(session, cmd);
try
{
_attributeChanged.OnNext(ctx);
}
catch (Exception ex)
{
NotifyEventError(log, ex);
}
IModelElement mel;
if (notifications.TryGetValue(cmd.Id, out mel))
{
var propertyName = cmd.PropertyName;
NotifyPropertyChanged(mel, propertyName);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="EventContext{T}" /> class.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="event">The event.</param>
internal EventContext(ISessionInformation session, T @event)
{
DebugContract.Requires(session);
DebugContract.Requires(@event);
Event = @event;
Session = session;
}
public BaseController(IMediator mediator, NoticeBoardContext databaseContext, IConfiguration configuration, IMapper mapper, ISessionInformation sessionInformation, IDataProtectionProvider dataProtectionProvider)
{
_configuration = configuration;
_mediator = mediator;
_context = databaseContext;
_mapper = mapper;
_sessionInformation = sessionInformation;
_dataProtectionProvider = dataProtectionProvider;
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Sends a message.
/// </summary>
/// <param name="originStoreId">
/// Identifier for the origin store.
/// </param>
/// <param name="session">
/// The mode.
/// </param>
/// <param name="events">
/// The events.
/// </param>
/// <returns>
/// A Message.
/// </returns>
///-------------------------------------------------------------------------------------------------
protected virtual Message SendMessage(string originStoreId, ISessionInformation session, IEnumerable <IEvent> events)
{
var msg = new Message {
sessionMode = session.Mode, events = new List <Enveloppe>()
};
msg.origin = originStoreId;
msg.sessionId = session.SessionId;
msg.events = events.Select(e => new Enveloppe(e)).ToList();
return(msg);
}
public void CompleteUpdateInformation(ISessionInformation sessionInformation)
{
Session session = sessionInformation?.GetSession();
if (session?.User == null)
{
return;
}
UpdateBy = sessionInformation.GetSession().User.Id;
}
public void CompleteInsertInformation(ISessionInformation sessionInformation)
{
Session session = sessionInformation?.GetSession();
if (session?.User == null)
{
return;
}
InsertBy = UpdateBy = sessionInformation.GetSession().User.Id;
IsArchive = 0;
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Empile les événements de la session en agrégeant tous les événements sur le même n° de
/// session.
/// </summary>
/// <param name="session">
/// .
/// </param>
///-------------------------------------------------------------------------------------------------
protected virtual void Push(ISessionInformation session)
{
if (session.IsReadOnly || (session.Mode & SessionMode.Loading) == SessionMode.Loading)
{
return;
}
var eventsQuery = session.Events.OfType <IUndoableEvent>()
.Where(e =>
{
/*e.IsTopLevelEvent &&*/
DomainInfo info;
if (!_domainModels.TryGetValue(e.Domain, out info))
{
return(false);
}
return(info.Filter == null || info.Filter(e));
});
var events = eventsQuery.ToList();
if (events.Count > 0)
{
lock (_sync)
{
_redos.Clear();
OnPropertyChanged("CanRedo");
// Est ce qu'il existe une session identique ?
foreach (var ci in _undos)
{
if (ci.SessionId == session.SessionId)
{
ci.Events.AddRange(events);
return;
}
}
_undos.Push(new SessionEvents
{
SessionId = session.SessionId,
Events = events.ToList()
});
}
}
OnPropertyChanged("CanUndo");
}
private Tuple <ExecutionResult, ISessionInformation> CompleteTopLevelTransaction(IEnumerable <IEventNotifier> notifiers, SessionDataContext ctx, SessionLocalInfo currentInfo)
{
// Sauvegarde des références vers les objets qui sont utilisés aprés que les données de la session auront été supprimées
ExecutionResult messages = null;
ISessionInformation sessionInfo = null;
// Il ne peut pas y avoir d'erreur dans cette partie de code
try
{
ctx.Disposing = true;
// Si la session était en lecture seule, on simplifie les traitements
// Pas de validation
if (!ctx.ReadOnly)
{
messages = ExecuteConstraints(ctx, currentInfo);
}
// Contexte en lecture seule de la session mais tjs dans le scope
// Envoi des events même en read-only pour s'assurer que le OnSessionCompleted soit bien notifié
if (!ctx.CancellationToken.IsCancellationRequested)
{
using (CodeMarker.MarkBlock("Session.OnSessionCompleted"))
{
sessionInfo = OnSessionCompleted(currentInfo, notifiers, messages);
}
}
// Si tout va bien, on commite
if (!IsAborted && _scope != null && (messages == null || !messages.HasErrors))
{
_scope.Complete();
}
}
catch (Exception ex)
{
Log(new DiagnosticMessage(MessageType.Error, ex.Message, ExceptionMessages.Diagnostic_ApplicationError, SessionDataContext.InValidationProcess, null, ex));
}
finally
{
DisposeSession(ctx);
}
return(Tuple.Create(messages ?? ExecutionResult.Empty, sessionInfo));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Send all validations message raises during the session.
/// </summary>
/// <param name="session">
/// .
/// </param>
/// <param name="result">
/// The result.
/// </param>
///-------------------------------------------------------------------------------------------------
public void NotifyMessages(ISessionInformation session, ISessionResult result)
{
Contract.Requires(session, "session");
Contract.Requires(result, "result");
_messageOccurs.OnNext(result);
if (session.IsReadOnly)
{
return;
}
foreach (var mel in PrepareNotificationList(session).Values)
{
var den = mel as IDataErrorNotifier;
if (den != null)
{
den.NotifyDataErrors(result);
}
}
}
private Dictionary <Identity, IModelElement> PrepareNotificationList(ISessionInformation session)
{
var list = new Dictionary <Identity, IModelElement>();
_attributedChangedObserversSync.EnterReadLock();
try
{
foreach (var mel in session.TrackingData.InvolvedModelElements)
{
if (_attributedChangedObservers.ContainsKey(mel.Id))
{
list.Add(mel.Id, mel);
}
}
}
finally
{
_attributedChangedObserversSync.ExitReadLock();
}
return(list);
}
public GetCharacterGenerationOptionsQueryHandler(NoticeBoardContext context, ISessionInformation sessionInformation, IMapper mapper)
{
_context = context;
_mapper = mapper;
}
public GetCampaignQueryHandler(NoticeBoardContext context, ISessionInformation sessionInformation, IMapper mapper)
{
_context = context;
_sessionInformation = sessionInformation;
_mapper = mapper;
}
public CreatePCCommandHandler(NoticeBoardContext context, ISessionInformation sessionInformation)
{
_context = context;
_sessionInformation = sessionInformation;
}
public GetSourcesQueryHandler(NoticeBoardContext context, ISessionInformation sessionInformation, IMapper mapper)
{
_context = context;
_mapper = mapper;
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionCompletingEventArgs" /> class.
/// </summary>
/// <param name="session">The session.</param>
internal SessionCompletingEventArgs(ISessionInformation session)
{
DebugContract.Requires(session);
Session = session;
}
public CampaignController(IMediator mediator, NoticeBoardContext databaseContext, IConfiguration configuration, IMapper mapper, ISessionInformation sessionInformation, IDataProtectionProvider dataProtectionProvider) :
base(mediator, databaseContext, configuration, mapper, sessionInformation, dataProtectionProvider)
{
}
void IEventNotifier.NotifyEvent(ISessionInformation session, ISessionContext log, IEvent ev)
{
DebugContract.Requires(session, "session");
DebugContract.Requires(log, "log");
DebugContract.Requires(ev, "ev");
if (String.Compare(ev.Domain, _domainModel.Name, StringComparison.OrdinalIgnoreCase) != 0)
{
return;
}
// Event for extendee domain will be raised to its extension
if (ev.ExtensionName != null && ev.ExtensionName != _domainModel.ExtensionName)
{
return;
}
try
{
if (ev is ChangePropertyValueEvent)
{
_attributeChanging.OnNext(new EventContext <ChangePropertyValueEvent>(session, (ChangePropertyValueEvent)ev));
}
else if (ev is AddEntityEvent)
{
_elementAdding.OnNext(new EventContext <AddEntityEvent>(session, (AddEntityEvent)ev));
}
else if (ev is AddRelationshipEvent)
{
_relationshipAdding.OnNext(new EventContext <AddRelationshipEvent>(session, (AddRelationshipEvent)ev));
}
else if (ev is RemoveRelationshipEvent)
{
_relationshipRemoving.OnNext(new EventContext <RemoveRelationshipEvent>(session, (RemoveRelationshipEvent)ev));
}
else if (ev is RemoveEntityEvent)
{
_elementRemoving.OnNext(new EventContext <RemoveEntityEvent>(session, (RemoveEntityEvent)ev));
}
else if (ev is RemovePropertyEvent)
{
_attributeRemoving.OnNext(new EventContext <RemovePropertyEvent>(session, (RemovePropertyEvent)ev));
}
else if (ev is AddSchemaEntityEvent)
{
_metadataAdding.OnNext(new EventContext <AddSchemaEntityEvent>(session, (AddSchemaEntityEvent)ev));
}
else if (ev is AddSchemaRelationshipEvent)
{
_relationshipMetadataAdding.OnNext(new EventContext <AddSchemaRelationshipEvent>(session, (AddSchemaRelationshipEvent)ev));
}
else
{
_customEventRaising.OnNext(new EventContext <IEvent>(session, ev));
}
}
catch (Exception ex)
{
NotifyEventError(log, ex);
}
}
void IEventBusChannel.SendEvents(ISessionInformation session)
{
DebugContract.Requires(session);
SendEvents(session);
}
/// <summary>
/// Send events when the session end (correctly or not)
/// </summary>
/// <param name="session"></param>
/// <param name="log"></param>
void IEventNotifier.NotifySessionCompleted(ISessionInformation session, ISessionContext log)
{
DebugContract.Requires(session, "session");
DebugContract.Requires(log, "log");
if (!session.Events.Any(e => String.Compare(e.Domain, _domainModel.Name, StringComparison.OrdinalIgnoreCase) == 0 && (e.ExtensionName == null || e.ExtensionName == _domainModel.ExtensionName)))
{
return;
}
try
{
_sessionCompleting.OnNext(session);
}
catch (Exception ex)
{
NotifyEventError(log, ex);
}
// Si la session s'est terminée anormalement, aucun autre événement n'est envoyé
if (!session.IsAborted && (session.Mode & SessionMode.SkipNotifications) != SessionMode.SkipNotifications)
{
var notifiedProperties = new HashSet <Identity>();
var notifications = PrepareNotificationList(session);
foreach (var ev in session.Events.Where(e => String.Compare(e.Domain, _domainModel.Name, StringComparison.OrdinalIgnoreCase) == 0))
{
// Utiliser plutot le eventbus
// this._eventDispatcher.HandleEvent(ev);
try
{
if (ev is AddEntityEvent)
{
_elementAdded.OnNext(new EventContext <AddEntityEvent>(session, (AddEntityEvent)ev));
}
else if (ev is AddRelationshipEvent)
{
var evt = (AddRelationshipEvent)ev;
_relationshipAdded.OnNext(new EventContext <AddRelationshipEvent>(session, evt));
var relationshipSchema = session.Store.GetSchemaRelationship(evt.SchemaId, false);
if (relationshipSchema != null && (relationshipSchema.Schema.Behavior & DomainBehavior.Observable) == DomainBehavior.Observable)
{
IModelElement mel;
if (notifications.TryGetValue(evt.StartId, out mel) && relationshipSchema.StartPropertyName != null)
{
var key = mel.Id.CreateAttributeIdentity(relationshipSchema.StartPropertyName);
if (notifiedProperties.Add(key))
{
NotifyPropertyChanged(mel, relationshipSchema.StartPropertyName);
}
}
if (notifications.TryGetValue(evt.EndId, out mel) && relationshipSchema.EndPropertyName != null)
{
var key = mel.Id.CreateAttributeIdentity(relationshipSchema.EndPropertyName);
if (notifiedProperties.Add(key))
{
NotifyPropertyChanged(mel, relationshipSchema.EndPropertyName);
}
}
}
}
else if (ev is RemoveRelationshipEvent)
{
var evt = (RemoveRelationshipEvent)ev;
_relationshipRemoved.OnNext(new EventContext <RemoveRelationshipEvent>(session, evt));
var relationshipSchema = session.Store.GetSchemaRelationship(evt.SchemaId, false);
if (relationshipSchema != null && (relationshipSchema.Schema.Behavior & DomainBehavior.Observable) == DomainBehavior.Observable)
{
IModelElement mel;
if (notifications.TryGetValue(evt.StartId, out mel) && relationshipSchema.StartPropertyName != null)
{
var key = mel.Id.CreateAttributeIdentity(relationshipSchema.StartPropertyName);
if (notifiedProperties.Add(key))
{
NotifyPropertyChanged(mel, relationshipSchema.StartPropertyName);
}
}
if (notifications.TryGetValue(evt.EndId, out mel) && relationshipSchema.EndPropertyName != null)
{
var key = mel.Id.CreateAttributeIdentity(relationshipSchema.EndPropertyName);
if (notifiedProperties.Add(key))
{
NotifyPropertyChanged(mel, relationshipSchema.EndPropertyName);
}
}
}
}
else if (ev is RemoveEntityEvent)
{
_elementRemoved.OnNext(new EventContext <RemoveEntityEvent>(session, (RemoveEntityEvent)ev));
}
else if (ev is RemovePropertyEvent)
{
_attributeRemoved.OnNext(new EventContext <RemovePropertyEvent>(session, (RemovePropertyEvent)ev));
}
else if (ev is ChangePropertyValueEvent)
{
var cmd = (ChangePropertyValueEvent)ev;
OnChangedAttributeEvent(session, log, cmd, notifications);
}
else if (ev is AddSchemaEntityEvent)
{
_metadataAdded.OnNext(new EventContext <AddSchemaEntityEvent>(session, (AddSchemaEntityEvent)ev));
}
else if (ev is AddSchemaRelationshipEvent)
{
_relationshipMetadataAdded.OnNext(new EventContext <AddSchemaRelationshipEvent>(session, (AddSchemaRelationshipEvent)ev));
}
else
{
_customEvents.OnNext(new EventContext <IEvent>(session, ev));
}
}
catch (Exception ex)
{
NotifyEventError(log, ex);
}
}
}
try
{
_sessionCompleted.OnNext(session);
}
catch (Exception ex)
{
NotifyEventError(log, ex);
}
}