public void ObjectChanged(INakedObjectAdapter nakedObjectAdapter, ILifecycleManager lifecycleManager, IMetamodelManager metamodel)
{
if (nakedObjectAdapter.ResolveState.RespondToChangesInPersistentObjects())
{
if (nakedObjectAdapter.Spec.ContainsFacet(typeof(IComplexTypeFacet)))
{
nakedObjectAdapter.Updating();
nakedObjectAdapter.Updated();
}
else
{
var spec = nakedObjectAdapter.Spec;
if (spec.IsAlwaysImmutable() || spec.IsImmutableOncePersisted() && nakedObjectAdapter.ResolveState.IsPersistent())
{
throw new NotPersistableException(logger.LogAndReturn("cannot change immutable object"));
}
nakedObjectAdapter.Updating();
if (!spec.IsNeverPersisted())
{
objectStore.ExecuteSaveObjectCommand(nakedObjectAdapter);
}
nakedObjectAdapter.Updated();
}
}
if (nakedObjectAdapter.ResolveState.RespondToChangesInPersistentObjects() ||
nakedObjectAdapter.ResolveState.IsTransient())
{
}
}
public CollectionFacetsTest()
{
lifecycleManager = mockLifecycleManager.Object;
persistor = mockPersistor.Object;
manager = mockManager.Object;
mockManager.Setup(mm => mm.CreateAdapter(It.IsAny <object>(), null, null)).Returns <object, IOid, IVersion>((obj, oid, ver) => AdapterFor(obj));
}
private ImplementationHidingCachingPicoContainer(IPicoContainer parent, CachingComponentAdapterFactory caf,
ILifecycleManager lifecycleManager)
: base(new ImplementationHidingPicoContainer(caf, parent, lifecycleManager))
{
this.caf = caf;
this.lifecycleManager = lifecycleManager;
}
public NakedObjectAdapter(IMetamodelManager metamodel,
ISession session,
IObjectPersistor persistor,
ILifecycleManager lifecycleManager,
INakedObjectManager nakedObjectManager,
object poco,
IOid oid,
ILoggerFactory loggerFactory,
ILogger <NakedObjectAdapter> logger)
{
this.metamodel = metamodel ?? throw new InitialisationException($"{nameof(metamodel)} is null");
this.session = session ?? throw new InitialisationException($"{nameof(session)} is null");
this.persistor = persistor ?? throw new InitialisationException($"{nameof(persistor)} is null");
this.nakedObjectManager = nakedObjectManager ?? throw new InitialisationException($"{nameof(nakedObjectManager)} is null");
this.logger = logger ?? throw new InitialisationException($"{nameof(logger)} is null");
this.lifecycleManager = lifecycleManager ?? throw new InitialisationException($"{nameof(lifecycleManager)} is null");
if (poco is INakedObjectAdapter)
{
throw new AdapterException(logger.LogAndReturn($"Adapter can't be used to adapt an adapter: {poco}"));
}
Object = poco;
Oid = oid;
ResolveState = new ResolveStateMachine(this, session);
Version = new NullVersion(loggerFactory.CreateLogger <NullVersion>());
}
public void ObjectChanged(INakedObject nakedObject, ILifecycleManager lifecycleManager, IMetamodelManager metamodel)
{
Log.DebugFormat("ObjectChanged nakedObject: {0}", nakedObject);
if (nakedObject.ResolveState.RespondToChangesInPersistentObjects())
{
if (nakedObject.Spec.ContainsFacet(typeof(IComplexTypeFacet)))
{
nakedObject.Updating();
nakedObject.Updated();
}
else
{
ITypeSpec spec = nakedObject.Spec;
if (spec.IsAlwaysImmutable() || (spec.IsImmutableOncePersisted() && nakedObject.ResolveState.IsPersistent()))
{
throw new NotPersistableException("cannot change immutable object");
}
nakedObject.Updating();
objectStore.ExecuteSaveObjectCommand(nakedObject);
nakedObject.Updated();
}
}
if (nakedObject.ResolveState.RespondToChangesInPersistentObjects() ||
nakedObject.ResolveState.IsTransient())
{
}
}
public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
: base(factory) {
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.transactionManager = transactionManager;
NakedObject = nakedObjectAdapter;
}
public ActionSpec(SpecFactory memberFactory,
IMetamodelManager metamodel,
ILifecycleManager lifecycleManager,
ISession session,
IServicesManager servicesManager,
INakedObjectManager nakedObjectManager,
IActionSpecImmutable actionSpecImmutable,
IMessageBroker messageBroker,
ITransactionManager transactionManager,
IObjectPersistor persistor,
ILoggerFactory loggerFactory,
ILogger <ActionSpec> logger)
: base(actionSpecImmutable?.Identifier?.MemberName, actionSpecImmutable, session, lifecycleManager, metamodel, persistor)
{
this.servicesManager = servicesManager ?? throw new InitialisationException($"{nameof(servicesManager)} is null");
this.nakedObjectManager = nakedObjectManager ?? throw new InitialisationException($"{nameof(nakedObjectManager)} is null");
this.actionSpecImmutable = actionSpecImmutable ?? throw new InitialisationException($"{nameof(actionSpecImmutable)} is null");
this.messageBroker = messageBroker ?? throw new InitialisationException($"{nameof(messageBroker)} is null");
this.transactionManager = transactionManager ?? throw new InitialisationException($"{nameof(transactionManager)} is null");
this.loggerFactory = loggerFactory ?? throw new InitialisationException($"{nameof(loggerFactory)} is null");
this.logger = logger ?? throw new InitialisationException($"{nameof(logger)} is null");
var index = 0;
Parameters = this.actionSpecImmutable.Parameters.Select(pp => memberFactory.CreateParameter(pp, this, index++)).ToArray();
}
protected AssociationSpecAbstract(IMetamodelManager metamodel, IAssociationSpecImmutable association, ISession session, ILifecycleManager lifecycleManager, INakedObjectManager manager)
: base(association.Identifier.MemberName, association, session, lifecycleManager, metamodel) {
Assert.AssertNotNull(manager);
this.manager = manager;
returnSpec = MetamodelManager.GetSpecification(association.ReturnSpec);
}
private ImplementationHidingCachingPicoContainer(IPicoContainer parent, CachingComponentAdapterFactory caf,
ILifecycleManager lifecycleManager)
: base(new ImplementationHidingPicoContainer(caf, parent, lifecycleManager))
{
this.caf = caf;
this.lifecycleManager = lifecycleManager;
}
/// <summary>
/// Creates a new container with a parent container.
/// </summary>
/// <param name="caf"></param>
/// <param name="parent"></param>
/// <param name="lifecycleManager"></param>
public CachingPicoContainer(CachingComponentAdapterFactory caf, IPicoContainer parent,
ILifecycleManager lifecycleManager)
: base(new DefaultPicoContainer(caf, parent, lifecycleManager))
{
this.lifecycleManager = lifecycleManager;
this.caf = caf;
}
/// <summary>
/// Creates a new container with a parent container.
/// </summary>
/// <param name="caf"></param>
/// <param name="parent"></param>
/// <param name="lifecycleManager"></param>
public ImplementationHidingPicoContainer(IComponentAdapterFactory caf, IPicoContainer parent,
ILifecycleManager lifecycleManager)
: base(new DefaultPicoContainer(caf, parent, lifecycleManager))
{
this.caf = caf;
this.lifecycleManager = lifecycleManager;
}
public NakedObjectsFramework(IMessageBroker messageBroker,
ISession session,
ILifecycleManager lifecycleManager,
IServicesManager servicesManager,
INakedObjectManager nakedObjectManager,
IObjectPersistor persistor,
IReflector reflector,
IMetamodelManager metamodelManagerManager,
IContainerInjector containerInjector,
NakedObjectFactory nakedObjectFactory,
SpecFactory memberFactory,
ITransactionManager transactionManager,
IFrameworkResolver frameworkResolver)
{
this.messageBroker = messageBroker;
this.session = session;
this.lifecycleManager = lifecycleManager;
this.servicesManager = servicesManager;
this.nakedObjectManager = nakedObjectManager;
this.persistor = persistor;
this.reflector = reflector;
this.metamodelManagerManager = metamodelManagerManager;
this.containerInjector = containerInjector;
this.transactionManager = transactionManager;
this.frameworkResolver = frameworkResolver;
containerInjector.Framework = this;
memberFactory.Initialize(this);
nakedObjectFactory.Initialize(metamodelManagerManager, session, lifecycleManager, persistor, nakedObjectManager);
}
protected override IMutablePicoContainer CreatePicoContainer(IPicoContainer parent,
ILifecycleManager lifecycleManager)
{
return
(new ImplementationHidingCachingPicoContainer(
new CachingComponentAdapterFactory(new DefaultComponentAdapterFactory()), parent, lifecycleManager));
}
private CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel) {
Assert.AssertNotNull(lifecycleManager);
Assert.AssertNotNull(nakedObjectManager);
this.lifecycleManager = lifecycleManager;
this.nakedObjectManager = nakedObjectManager;
this.metamodel = metamodel;
}
public NakedObjectsFramework(IMessageBroker messageBroker,
ISession session,
ILifecycleManager lifecycleManager,
IServicesManager servicesManager,
INakedObjectManager nakedObjectManager,
IObjectPersistor persistor,
IReflector reflector,
IMetamodelManager metamodelManagerManager,
IDomainObjectInjector domainObjectInjector,
NakedObjectFactory nakedObjectFactory,
SpecFactory memberFactory,
ITransactionManager transactionManager,
IFrameworkResolver frameworkResolver,
ILoggerFactory loggerFactory)
{
MessageBroker = messageBroker;
Session = session;
LifecycleManager = lifecycleManager;
ServicesManager = servicesManager;
NakedObjectManager = nakedObjectManager;
Persistor = persistor;
Reflector = reflector;
MetamodelManager = metamodelManagerManager;
DomainObjectInjector = domainObjectInjector;
TransactionManager = transactionManager;
FrameworkResolver = frameworkResolver;
domainObjectInjector.Framework = this;
memberFactory.Initialize(this, loggerFactory, loggerFactory.CreateLogger <SpecFactory>());
nakedObjectFactory.Initialize(metamodelManagerManager, session, lifecycleManager, persistor, nakedObjectManager, loggerFactory);
}
public OneToManyAssociationSpec(IMetamodelManager metamodel, IOneToManyAssociationSpecImmutable association, ISession session, ILifecycleManager lifecycleManager, INakedObjectManager manager, IObjectPersistor persistor)
: base(metamodel, association, session, lifecycleManager, manager) {
this.persistor = persistor;
isASet = association.ContainsFacet<IIsASetFacet>();
elementSpec = MetamodelManager.GetSpecification(association.ElementSpec);
}
protected override IMutablePicoContainer CreatePicoContainer(IPicoContainer parent,
ILifecycleManager lifecycleManager)
{
return
new ImplementationHidingCachingPicoContainer(
new CachingComponentAdapterFactory(new DefaultComponentAdapterFactory()), parent, lifecycleManager);
}
private void RegisterTypes(Type resolvableType, Type implementationType, ILifecycleManager lifecycleManager)
{
if (implementationType.IsAbstract)
{
throw new AbstractClassNotAllowedException(implementationType);
}
// Design assumption: Implementation classes must have only one public constructor.
// My gut says that if there is more than one public constructor, then the dependencies in the class haven't been made very clear.
// Side benefit of checking constructors: it ensures the implementation type is actually a class (instead of an interface or a delegate, for instance).
var constructors = implementationType.GetConstructors();
if (constructors.Length == 0)
{
throw new NoPublicConstructorsException(implementationType);
}
if (constructors.Length > 1)
{
throw new MoreThanOnePublicConstructorException(implementationType);
}
var constructor = constructors.Single();
this.constructors.Add(resolvableType, constructor);
this.lifecycleManagers.Add(resolvableType, lifecycleManager);
}
/// <summary>
/// Creates a new container with a parent container.
/// </summary>
/// <param name="caf"></param>
/// <param name="parent"></param>
/// <param name="lifecycleManager"></param>
public ImplementationHidingPicoContainer(IComponentAdapterFactory caf, IPicoContainer parent,
ILifecycleManager lifecycleManager)
: base(new DefaultPicoContainer(caf, parent, lifecycleManager))
{
this.caf = caf;
this.lifecycleManager = lifecycleManager;
}
/// <summary>
/// Creates a new container with a parent container.
/// </summary>
/// <param name="caf"></param>
/// <param name="parent"></param>
/// <param name="lifecycleManager"></param>
public CachingPicoContainer(CachingComponentAdapterFactory caf, IPicoContainer parent,
ILifecycleManager lifecycleManager)
: base(new DefaultPicoContainer(caf, parent, lifecycleManager))
{
this.lifecycleManager = lifecycleManager;
this.caf = caf;
}
private bool IsEditableOrVisible(ISession session, ILifecycleManager lifecycleManager, IMetamodelManager manager, INakedObject target, IIdentifier identifier, string toInvoke)
{
Assert.AssertNotNull(target);
object authorizer = GetTypeAuthorizerFor(target, lifecycleManager, manager) ?? GetDefaultAuthorizer(lifecycleManager, manager);
return((bool)authorizer.GetType().GetMethod(toInvoke).Invoke(authorizer, new[] { session.Principal, target.Object, identifier.MemberName }));
}
private CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel)
{
Assert.AssertNotNull(lifecycleManager);
Assert.AssertNotNull(nakedObjectManager);
this.lifecycleManager = lifecycleManager;
this.nakedObjectManager = nakedObjectManager;
this.metamodel = metamodel;
}
public override void SetUp()
{
base.SetUp();
facetFactory = new AuthorizeAnnotationFacetFactory(0);
mockPersistor = new Mock <ILifecycleManager>();
lifecycleManager = mockPersistor.Object;
}
private IAuditor GetNamespaceAuditorFor(INakedObjectAdapter target, ILifecycleManager lifecycleManager)
{
var fullyQualifiedOfTarget = target.Spec.FullName;
// order here as ImmutableDictionary not ordered
var auditor = namespaceAuditors.OrderByDescending(x => x.Key.Length).Where(x => fullyQualifiedOfTarget.StartsWith(x.Key)).Select(x => x.Value).FirstOrDefault();
return(auditor != null?CreateAuditor(auditor, lifecycleManager) : null);
}
public void Register <TInterface, TImplementation>(ILifecycleManager lifecycleManager) where TInterface : class
where TImplementation : class, TInterface
{
var registration = new Registration(typeof(TInterface), typeof(TImplementation),
lifecycleManager);
_registrations.Add(typeof(TInterface), registration);
}
public override void SetProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager) {
try {
property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null);
}
catch (TargetInvocationException e) {
InvokeUtils.InvocationException("Exception executing " + property, e);
}
}
public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
: base(factory)
{
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.transactionManager = transactionManager;
NakedObject = nakedObjectAdapter;
}
public static bool IsVisible(ISpecification specification, IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
var buf = new InteractionBuffer();
IEnumerable<IHidingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IHidingInteractionAdvisor).Cast<IHidingInteractionAdvisor>();
foreach (IHidingInteractionAdvisor advisor in facets) {
buf.Append(advisor.Hides(ic, lifecycleManager, manager));
}
return IsVisible(buf);
}
private CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel, ILogger <CollectionMemento> logger)
{
this.lifecycleManager = lifecycleManager ?? throw new InitialisationException($"{nameof(lifecycleManager)} is null");
;
this.nakedObjectManager = nakedObjectManager ?? throw new InitialisationException($"{nameof(nakedObjectManager)} is null");
;
this.metamodel = metamodel ?? throw new InitialisationException($"{nameof(metamodel)} is null");
this.logger = logger ?? throw new InitialisationException($"{nameof(logger)} is null");
}
public void SetUp()
{
_lifecycleManager = new LifecycleManager();
_liveDataMock = new Mock <ILiveData <string> >();
_liveDataMock.Setup(liveData => liveData.Subscribe(
It.IsAny <Action <string> >(), It.IsAny <Action <Exception> >(), It.IsAny <Action>()))
.Returns(new Mock <IDisposable>().Object);
}
public override void Invoke(INakedObjectAdapter nakedObjectAdapter, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager) {
profileManager.Begin(session, associatedEvent, "", nakedObjectAdapter, lifecycleManager);
try {
underlyingFacet.Invoke(nakedObjectAdapter, session, lifecycleManager, metamodelManager);
}
finally {
profileManager.End(session, associatedEvent, "", nakedObjectAdapter, lifecycleManager);
}
}
private object GetTypeAuthorizerFor(INakedObject target, ILifecycleManager lifecycleManager, IMetamodelManager manager)
{
Assert.AssertNotNull(target);
Type domainType = TypeUtils.GetType(target.Spec.FullName).GetProxiedType();
Type authorizer;
typeAuthorizers.TryGetValue(domainType, out authorizer);
return(authorizer == null ? null : CreateAuthorizer(authorizer, lifecycleManager, manager));
}
public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager)
: base(factory)
{
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.transactionManager = transactionManager;
Log.DebugFormat("Created test object for {0}", nakedObjectAdapter);
NakedObject = nakedObjectAdapter;
}
public override INakedObjectAdapter Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, int resultPage, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager) {
profileManager.Begin(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager);
try {
return underlyingFacet.Invoke(nakedObjectAdapter, parameters, resultPage, lifecycleManager, manager, session, nakedObjectManager, messageBroker, transactionManager);
}
finally {
profileManager.End(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager);
}
}
public CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel, INakedObjectAdapter target, IActionSpec actionSpec, INakedObjectAdapter[] parameters)
: this(lifecycleManager, nakedObjectManager, metamodel) {
Target = target;
Action = actionSpec;
Parameters = parameters;
if (Target.Spec.IsViewModel) {
lifecycleManager.PopulateViewModelKeys(Target);
}
}
public TestObjectFactory(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectManager manager, ITransactionManager transactionManager, IServicesManager servicesManager)
{
this.metamodelManager = metamodelManager;
Session = session;
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.manager = manager;
this.transactionManager = transactionManager;
this.servicesManager = servicesManager;
}
public CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel, ILogger <CollectionMemento> logger, CollectionMemento otherMemento, object[] selectedObjects)
: this(lifecycleManager, nakedObjectManager, metamodel, logger)
{
IsPaged = otherMemento.IsPaged;
IsNotQueryable = otherMemento.IsNotQueryable;
Target = otherMemento.Target;
Action = otherMemento.Action;
Parameters = otherMemento.Parameters;
SelectedObjects = selectedObjects;
}
public void Activate(object viewModel)
{
Ensure.ArgumentMatches(!this.managers.ContainsKey(viewModel), viewModel, "viewModel", "The view model is already activated.");
ILifecycleManager manager = this.managerFactory.Create(viewModel);
this.managers.Add(viewModel, manager);
manager.Activate();
}
public void Deactivate(object viewModel)
{
Ensure.ArgumentMatches(this.managers.ContainsKey(viewModel), viewModel, "viewModel", "The view model is not activated.");
ILifecycleManager manager = this.managers[viewModel];
manager.Deactivate();
this.managers.Remove(viewModel);
}
public bool IsEditable(ISession session, ILifecycleManager lifecycleManager, INakedObjectAdapter target, IIdentifier identifier) {
object authorizer = GetAuthorizer(target, lifecycleManager);
Type authType = authorizer.GetType();
if ((typeof(INamespaceAuthorizer)).IsAssignableFrom(authType)) {
var nameAuth = (INamespaceAuthorizer) authorizer;
return nameAuth.IsEditable(session.Principal, target.Object, identifier.MemberName);
}
return isEditableDelegates[authType](authorizer, session.Principal, target.GetDomainObject(), identifier.MemberName);
}
public TestObjectFactory(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectManager manager, ITransactionManager transactionManager, IServicesManager servicesManager, IMessageBroker messageBroker) {
this.metamodelManager = metamodelManager;
Session = session;
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.manager = manager;
this.transactionManager = transactionManager;
this.servicesManager = servicesManager;
this.messageBroker = messageBroker;
}
// ReSharper disable ParameterHidesMember
public void Initialize(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectManager nakedObjectManager, ILoggerFactory loggerFactory)
{
// ReSharper restore ParameterHidesMember
this.metamodelManager = metamodelManager ?? throw new InitialisationException($"{nameof(metamodelManager)} is null");
this.session = session ?? throw new InitialisationException($"{nameof(session)} is null");
this.lifecycleManager = lifecycleManager ?? throw new InitialisationException($"{nameof(lifecycleManager)} is null");
this.persistor = persistor ?? throw new InitialisationException($"{nameof(persistor)} is null");
this.nakedObjectManager = nakedObjectManager ?? throw new InitialisationException($"{nameof(nakedObjectManager)} is null");
this.loggerFactory = loggerFactory ?? throw new InitialisationException($"{nameof(loggerFactory)} is null");
isInitialized = true;
}
public bool IsEditable(ISession session, ILifecycleManager lifecycleManager, IMetamodelManager manager, INakedObject target, IIdentifier identifier)
{
object authorizer = GetAuthorizer(target, lifecycleManager, manager);
if (authorizer.GetType().IsAssignableFrom(typeof(INamespaceAuthorizer)))
{
var nameAuth = (ITypeAuthorizer <object>)authorizer;
return(nameAuth.IsEditable(session.Principal, target.Object, identifier.MemberName));
}
return((bool)ExecuteOnTypeAuthorizer(session, target, identifier, "IsEditable", authorizer));
}
private object GetAuthorizer(INakedObjectAdapter target, ILifecycleManager lifecycleManager)
{
//Look for exact-fit TypeAuthorizer
// order here as ImmutableDictionary not ordered
var fullyQualifiedOfTarget = target.Spec.FullName;
var authorizer = typeAuthorizers.Where(ta => ta.Key == fullyQualifiedOfTarget).Select(ta => ta.Value).FirstOrDefault() ??
namespaceAuthorizers.OrderByDescending(x => x.Key.Length).Where(x => fullyQualifiedOfTarget.StartsWith(x.Key)).Select(x => x.Value).FirstOrDefault() ??
defaultAuthorizer;
return(CreateAuthorizer(authorizer, lifecycleManager));
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, string contributor, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager)
{
SubMenu = contributor;
this.metamodelManager = metamodelManager;
this.session = session;
this.lifecycleManager = lifecycleManager;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
this.actionSpec = actionSpec;
}
public CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel, CollectionMemento otherMemento, object[] selectedObjects)
: this(lifecycleManager, nakedObjectManager, metamodel) {
Assert.AssertNotNull(otherMemento);
IsPaged = otherMemento.IsPaged;
IsNotQueryable = otherMemento.IsNotQueryable;
Target = otherMemento.Target;
Action = otherMemento.Action;
Parameters = otherMemento.Parameters;
SelectedObjects = selectedObjects;
}
/// <summary>
/// Creates a new container with a custom ComponentAdapterFactory and a parent container.
/// Important note about caching: If you intend the components to be cached, you should pass
/// in a factory that creates CachingComponentAdapter instances, such as for example
/// other ComponentAdapterFactories.
/// </summary>
/// <param name="componentAdapterFactory">the factory to use for creation of ComponentAdapters.</param>
/// <param name="parent">the parent container (used for component dependency lookups).</param>
/// <param name="lifecycleManager">the lifecycle manager to manage start/stop/dispose calls on the container.</param>
public DefaultPicoContainer(IComponentAdapterFactory componentAdapterFactory, IPicoContainer parent,
ILifecycleManager lifecycleManager)
{
this.lifecycleManager = lifecycleManager;
if (componentAdapterFactory == null)
{
throw new NullReferenceException("componentAdapterFactory");
}
this.componentAdapterFactory = componentAdapterFactory;
this.parent = parent; // == null ? null : new ImmutablePicoContainer(parent);
}
public TestAction(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, ITransactionManager transactionManager, string contributor, IActionSpec actionSpec, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager, IMessageBroker messageBroker) {
SubMenu = contributor;
this.metamodelManager = metamodelManager;
this.session = session;
this.lifecycleManager = lifecycleManager;
this.transactionManager = transactionManager;
this.messageBroker = messageBroker;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
this.actionSpec = actionSpec;
}
public void Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, bool queryOnly, IIdentifier identifier, ISession session, ILifecycleManager lifecycleManager) {
IAuditor auditor = GetAuditor(nakedObjectAdapter, lifecycleManager);
IPrincipal byPrincipal = session.Principal;
string memberName = identifier.MemberName;
if (nakedObjectAdapter.Spec is IServiceSpec) {
string serviceName = nakedObjectAdapter.Spec.GetTitle(nakedObjectAdapter);
auditor.ActionInvoked(byPrincipal, memberName, serviceName, queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
}
else {
auditor.ActionInvoked(byPrincipal, memberName, nakedObjectAdapter.GetDomainObject(), queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
}
}
public static bool IsVisibleWhenPersistent(ISpecification specification, IInteractionContext ic, ILifecycleManager lifecycleManager, IMetamodelManager manager) {
var buf = new InteractionBuffer();
IEnumerable<IHidingInteractionAdvisor> facets = specification.GetFacets().Where(f => f is IHidingInteractionAdvisor).Cast<IHidingInteractionAdvisor>();
foreach (IHidingInteractionAdvisor advisor in facets) {
var facet = advisor as IHiddenFacet;
if (facet != null) {
if (facet.Value == WhenTo.OncePersisted) {
continue;
}
}
buf.Append(advisor.Hides(ic, lifecycleManager, manager));
}
return IsVisible(buf);
}
// ReSharper disable ParameterHidesMember
public void Initialize(IMetamodelManager metamodelManager, ISession session, ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectManager nakedObjectManager) {
// ReSharper restore ParameterHidesMember
Assert.AssertNotNull(metamodelManager);
Assert.AssertNotNull(session);
Assert.AssertNotNull(lifecycleManager);
Assert.AssertNotNull(persistor);
Assert.AssertNotNull(nakedObjectManager);
this.metamodelManager = metamodelManager;
this.session = session;
this.lifecycleManager = lifecycleManager;
this.persistor = persistor;
this.nakedObjectManager = nakedObjectManager;
isInitialized = true;
}
public ActionSpec(SpecFactory memberFactory, IMetamodelManager metamodel, ILifecycleManager lifecycleManager, ISession session, IServicesManager servicesManager, INakedObjectManager nakedObjectManager, IActionSpecImmutable actionSpecImmutable, IMessageBroker messageBroker, ITransactionManager transactionManager)
: base(actionSpecImmutable.Identifier.MemberName, actionSpecImmutable, session, lifecycleManager, metamodel) {
Assert.AssertNotNull(memberFactory);
Assert.AssertNotNull(servicesManager);
Assert.AssertNotNull(nakedObjectManager);
Assert.AssertNotNull(actionSpecImmutable);
this.memberFactory = memberFactory;
this.servicesManager = servicesManager;
this.nakedObjectManager = nakedObjectManager;
this.actionSpecImmutable = actionSpecImmutable;
this.messageBroker = messageBroker;
this.transactionManager = transactionManager;
int index = 0;
parametersSpec = this.actionSpecImmutable.Parameters.Select(pp => this.memberFactory.CreateParameter(pp, this, index++)).ToArray();
}
public CollectionMemento(ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, IMetamodelManager metamodel, string[] strings)
: this(lifecycleManager, nakedObjectManager, metamodel) {
var helper = new StringDecoderHelper(metamodel, strings, true);
// ReSharper disable once UnusedVariable
string specName = helper.GetNextString();
string actionId = helper.GetNextString();
var targetOid = (IOid) helper.GetNextEncodedToStrings();
Target = RestoreObject(targetOid);
Action = Target.GetActionLeafNode(actionId);
var parameters = new List<INakedObjectAdapter>();
while (helper.HasNext) {
var parmType = helper.GetNextEnum<ParameterType>();
switch (parmType) {
case ParameterType.Value:
object obj = helper.GetNextObject();
parameters.Add(nakedObjectManager.CreateAdapter(obj, null, null));
break;
case ParameterType.Object:
var oid = (IOid) helper.GetNextEncodedToStrings();
INakedObjectAdapter nakedObjectAdapter = RestoreObject(oid);
parameters.Add(nakedObjectAdapter);
break;
case ParameterType.ValueCollection:
Type vInstanceType;
IList<object> vColl = helper.GetNextValueCollection(out vInstanceType);
IList typedVColl = CollectionUtils.ToTypedIList(vColl, vInstanceType);
parameters.Add(nakedObjectManager.CreateAdapter(typedVColl, null, null));
break;
case ParameterType.ObjectCollection:
Type oInstanceType;
List<object> oColl = helper.GetNextObjectCollection(out oInstanceType).Cast<IOid>().Select(o => RestoreObject(o).Object).ToList();
IList typedOColl = CollectionUtils.ToTypedIList(oColl, oInstanceType);
parameters.Add(nakedObjectManager.CreateAdapter(typedOColl, null, null));
break;
default:
throw new ArgumentException(string.Format("Unexpected parameter type value: {0}", parmType));
}
}
Parameters = parameters.ToArray();
}
public override INakedObjectAdapter Invoke(INakedObjectAdapter inObjectAdapter, INakedObjectAdapter[] parameters, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager) {
if (parameters.Length != paramCount) {
Log.Error(actionMethod + " requires " + paramCount + " parameters, not " + parameters.Length);
}
object result;
if (actionDelegate != null) {
result = actionDelegate(inObjectAdapter.GetDomainObject(), parameters.Select(no => no.GetDomainObject()).ToArray());
}
else {
Log.WarnFormat("Invoking action via reflection as no delegate {0}.{1}", onType, actionMethod);
result = InvokeUtils.Invoke(actionMethod, inObjectAdapter, parameters);
}
INakedObjectAdapter adaptedResult = nakedObjectManager.CreateAdapter(result, null, null);
return adaptedResult;
}
private object GetAuthorizer(INakedObjectAdapter target, ILifecycleManager lifecycleManager) {
Assert.AssertNotNull(target);
//Look for exact-fit TypeAuthorizer
string fullyQualifiedOfTarget = target.Spec.FullName;
Type authorizer = typeAuthorizers.
Where(ta => ta.Key == fullyQualifiedOfTarget).
Select(ta => ta.Value).
FirstOrDefault() ??
// already ordered OrderByDescending(x => x.Key.Length).
namespaceAuthorizers.
Where(x => fullyQualifiedOfTarget.StartsWith(x.Key)).
Select(x => x.Value).
FirstOrDefault() ??
defaultAuthorizer;
return CreateAuthorizer(authorizer, lifecycleManager);
}
public override void Invoke(INakedObjectAdapter nakedObjectAdapter, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager) {
createdDelegate(nakedObjectAdapter.GetDomainObject());
}
public override void Invoke(INakedObjectAdapter nakedObjectAdapter, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager) {}
/// <summary>
/// Creates a new container with a custom LifecycleManger and no parent container.*/
/// </summary>
/// <param name="lifecycleManager">the lifecycle manager to manage start/stop/dispose calls on the container.</param>
public DefaultPicoContainer(ILifecycleManager lifecycleManager) : this(new DefaultComponentAdapterFactory(), null, lifecycleManager)
{
}
public override INakedObjectAdapter Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, int resultPage, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager) {
return Invoke(nakedObjectAdapter, parameters, lifecycleManager, manager, session, nakedObjectManager, messageBroker, transactionManager);
}
private object CreateAuthorizer(Type type, ILifecycleManager lifecycleManager) {
return lifecycleManager.CreateNonAdaptedInjectedObject(type);
}
