///-------------------------------------------------------------------------------------------------
/// <summary>
/// Handles the given context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <returns>
/// An IEvent.
/// </returns>
///-------------------------------------------------------------------------------------------------
public IEvent Handle(ExecutionCommandContext <RemoveRelationshipCommand> context)
{
DebugContract.Requires(context);
var dm = DomainModel as IUpdatableDomainModel;
if (dm == null || Relationship == null)
{
return(null);
}
// Le noeud terminal n'existe peut-être pas réellement (si il fait partie d'un autre domaine qui n'est pas chargé)
// Il faut utiliser directement son id
var endId = Relationship.EndId;
// Avant la suppression effective
var @event = new RemoveRelationshipEvent(Relationship.DomainModel.Name,
Relationship.DomainModel.ExtensionName,
Relationship.Id,
Relationship.SchemaInfo.Id,
_startId,
endId,
context.CurrentSession.SessionId,
Version.Value);
using (CodeMarker.MarkBlock("RemoveRelationshipCommand.Handle"))
{
if (dm.RemoveRelationship(Relationship.Id, _throwExceptionIfNotExists) == null)
{
return(null);
}
}
return(@event);
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Handles the given context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <returns>
/// An IEvent.
/// </returns>
///-------------------------------------------------------------------------------------------------
public IEvent Handle(ExecutionCommandContext <ChangePropertyValueCommand> context)
{
DebugContract.Requires(context);
var dm = DomainModel as IUpdatableDomainModel;
if (dm == null)
{
return(null);
}
using (CodeMarker.MarkBlock("ChangeAttributeCommand.Handler"))
{
var pv = dm.SetPropertyValue(Element, SchemaProperty, Value, this.Version);
if (pv == null)
{
return(null);
}
OldValue = pv.OldValue;
OldVersion = pv.CurrentVersion;
}
var evt = new ChangePropertyValueEvent(Element.DomainModel.Name,
DomainModel.ExtensionName,
Element.Id,
Element.SchemaInfo.Id,
SchemaProperty.Name,
Value,
OldValue,
context.CurrentSession.SessionId,
Version.Value);
evt.SetInternalValue(Value, OldValue);
return(evt);
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Handles the given context.
/// </summary>
/// <exception cref="InvalidElementException">
/// Thrown when an Invalid Element error condition occurs.
/// </exception>
/// <param name="context">
/// The context.
/// </param>
/// <returns>
/// An IEvent.
/// </returns>
///-------------------------------------------------------------------------------------------------
public IEvent Handle(ExecutionCommandContext <AddRelationshipCommand> context)
{
DebugContract.Requires(context);
var dm = DomainModel as IUpdatableDomainModel;
if (dm == null)
{
return(null);
}
if (Start == null)
{
new InvalidElementException(Start.Id, "Source element must exists to create a relationship");
}
if (String.Compare(Start.Id.DomainModelName, EndId.DomainModelName, StringComparison.OrdinalIgnoreCase) == 0)
{
if (DomainModel.Store.GetElement(EndId) == null)
{
throw new InvalidElementException(EndId, "Target element must exists to create a relationship.");
}
}
using (CodeMarker.MarkBlock("AddRelationshipCommand.Handle"))
{
dm.CreateRelationship(Id, SchemaRelationship, Start, EndId, _element);
}
return(new AddRelationshipEvent(_domainModel.Name, DomainModel.ExtensionName, Id, SchemaRelationship.Id, Start.Id, EndId, context.CurrentSession.SessionId, Version.Value));
}
private ISessionResult CheckOrValidateElements(IEnumerable <IModelElement> elements, ConstraintKind kind, string category)
{
if (!elements.Any())
{
return(ExecutionResult.Empty);
}
var categoryTitle = category ?? (kind == ConstraintKind.Check ? "CheckConstraints" : "ValidationConstraints");
using (CodeMarker.MarkBlock("ConstraintsManager." + categoryTitle))
{
ISession session = null;
if (Session.Current == null)
{
session = Domain.Store.BeginSession(new SessionConfiguration {
Readonly = true
});
}
var ctx = new ConstraintContext(((ISessionInternal)Session.Current).SessionContext, categoryTitle, kind);
try
{
foreach (var mel in elements)
{
ctx.Element = mel;
var schema = mel.SchemaInfo;
try
{
if (kind == ConstraintKind.Check)
{
CheckElement(ctx, mel, schema);
}
else
{
ValidateElement(ctx, mel, schema, category);
}
}
catch (Exception ex)
{
((ISessionInternal)session).SessionContext.Log(new DiagnosticMessage(MessageType.Error, ex.Message, categoryTitle, false, mel));
}
}
}
finally
{
if (session != null)
{
session.AcceptChanges();
session.Dispose();
}
}
return(ctx.Messages);
}
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Handles the given context.
/// </summary>
/// <exception cref="ReadOnlyException">
/// Thrown when a Read Only error condition occurs.
/// </exception>
/// <param name="context">
/// The context.
/// </param>
/// <returns>
/// An IEvent.
/// </returns>
///-------------------------------------------------------------------------------------------------
public IEvent Handle(ExecutionCommandContext <AddSchemaPropertyCommand> context)
{
DebugContract.Requires(context);
var updatableMetaModel = DomainModel as IUpdatableSchema;
if (updatableMetaModel == null)
{
throw new ReadOnlyException("Read only schema");
}
using (CodeMarker.MarkBlock("AddPropertySchemaCommand.Handle"))
{
updatableMetaModel.AddPropertySchema(PropertyId, PropertySchema);
}
return(new AddSchemaPropertyEvent(DomainModel.Name, DomainModel.ExtensionName, PropertyId, PropertySchema.Id, context.CurrentSession.SessionId, Version.Value));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Handles the given context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <returns>
/// An IEvent.
/// </returns>
///-------------------------------------------------------------------------------------------------
public IEvent Handle(ExecutionCommandContext <AddEntityCommand> context)
{
DebugContract.Requires(context);
var dm = DomainModel as IUpdatableDomainModel;
if (dm == null)
{
return(null);
}
using (CodeMarker.MarkBlock("AddEntityCommand.Handle"))
{
_element = dm.CreateEntity(Id, SchemaEntity, _element) as IModelEntity;
}
return(new AddEntityEvent(DomainModel.Name, DomainModel.ExtensionName, Id, SchemaEntity.Id, context.CurrentSession.SessionId, Version.Value));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Handles the given context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <returns>
/// An IEvent.
/// </returns>
///-------------------------------------------------------------------------------------------------
public IEvent Handle(ExecutionCommandContext <RemoveEntityCommand> context)
{
DebugContract.Requires(context);
var dm = DomainModel as IUpdatableDomainModel;
if (dm == null || Entity == null)
{
return(null);
}
using (CodeMarker.MarkBlock("RemoveEntityCommand.Handle"))
{
if (dm.RemoveEntity(Entity.Id, _throwExceptionIfNotExists) == null)
{
return(null);
}
}
return(new RemoveEntityEvent(DomainModel.Name, DomainModel.ExtensionName, Entity.Id, Entity.SchemaInfo.Id, context.CurrentSession.SessionId, Version.Value));
}
///-------------------------------------------------------------------------------------------------
/// <summary>
/// Handles the given context.
/// </summary>
/// <param name="context">
/// The context.
/// </param>
/// <returns>
/// An IEvent.
/// </returns>
///-------------------------------------------------------------------------------------------------
public IEvent Handle(ExecutionCommandContext <RemovePropertyCommand> context)
{
DebugContract.Requires(context);
var dm = DomainModel as IUpdatableDomainModel;
if (dm == null)
{
return(null);
}
using (CodeMarker.MarkBlock("RemovePropertyCommand.Handle"))
{
var pv = DomainModel.GetPropertyValue(ElementId, SchemaProperty);
if (pv != null)
{
OldValue = pv.Value;
OldVersion = pv.CurrentVersion;
return(new RemovePropertyEvent(DomainModel.Name, DomainModel.ExtensionName, ElementId, SchemaId, SchemaProperty.Name, OldValue, context.CurrentSession.SessionId, OldVersion));
}
}
return(null);
}
