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); }
/// <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); }
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 })); }
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 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); }