public TestProperty(IObjectPersistor persistor, IAssociationSpec field, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager) {
this.persistor = persistor;
this.field = field;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
}
public LifeCycleManager(
IMetamodelManager metamodel,
IPersistAlgorithm persistAlgorithm,
IOidGenerator oidGenerator,
IDomainObjectInjector injector,
IObjectPersistor objectPersistor,
INakedObjectManager nakedObjectManager
)
{
Assert.AssertNotNull(metamodel);
Assert.AssertNotNull(persistAlgorithm);
Assert.AssertNotNull(oidGenerator);
Assert.AssertNotNull(injector);
Assert.AssertNotNull(objectPersistor);
Assert.AssertNotNull(nakedObjectManager);
this.metamodel = metamodel;
this.persistAlgorithm = persistAlgorithm;
this.oidGenerator = oidGenerator;
this.injector = injector;
this.objectPersistor = objectPersistor;
this.nakedObjectManager = nakedObjectManager;
Log.DebugFormat("Creating {0}", this);
}
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);
}
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 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);
}
public RecursivePersistAlgorithm(IObjectPersistor persistor, INakedObjectManager manager) {
Assert.AssertNotNull(persistor);
Assert.AssertNotNull(manager);
this.persistor = persistor;
this.manager = manager;
}
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();
}
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 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 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));
}
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);
}
public void SaveSequenceFile(ISequence sequence, string filePath)
{
filePath = _GetRootedPath(filePath, SequenceService.SequenceDirectory);
IObjectPersistor persistor = PersistorFactory.Instance.CreateSequencePersistor();
persistor.SaveToFile(sequence, filePath);
}
public RecursivePersistAlgorithm(IObjectPersistor persistor,
INakedObjectManager manager,
ILogger <RecursivePersistAlgorithm> logger)
{
this.persistor = persistor ?? throw new InitialisationException($"{nameof(persistor)} is null");
this.manager = manager ?? throw new InitialisationException($"{nameof(manager)} is null");
this.logger = logger ?? throw new InitialisationException($"{nameof(logger)} is null");
}
public RecursivePersistAlgorithm(IObjectPersistor persistor, INakedObjectManager manager)
{
Assert.AssertNotNull(persistor);
Assert.AssertNotNull(manager);
this.persistor = persistor;
this.manager = manager;
}
public ObjectSpec(SpecFactory memberFactory,
IMetamodelManager metamodelManager,
INakedObjectManager nakedObjectManager,
IObjectSpecImmutable innerSpec,
ISession session,
IObjectPersistor persistor,
ILogger <ObjectSpec> logger) :
base(memberFactory, metamodelManager, nakedObjectManager, innerSpec, session, persistor) => this.logger = logger;
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 TestProperty(IObjectPersistor persistor, IAssociationSpec field, ITestHasActions owningObject, ITestObjectFactory factory, INakedObjectManager manager)
{
this.persistor = persistor;
this.field = field;
this.owningObject = owningObject;
this.factory = factory;
this.manager = manager;
}
public void SaveProgramFile(Program program, string filePath)
{
filePath = _GetRootedPath(filePath, Program.ProgramDirectory);
filePath = Path.ChangeExtension(filePath, Program.Extension);
IObjectPersistor <Program> persistor = PersistorFactory.Instance.CreateProgramPersistor();
persistor.SaveToFile(program, filePath);
}
public void SaveElementNodeTemplateFile(ElementNodeTemplate elementNodeTemplate, string filePath)
{
filePath = _GetRootedPath(filePath, ElementNodeTemplate.Directory);
filePath = Path.ChangeExtension(filePath, ElementNodeTemplate.Extension);
IObjectPersistor <ElementNodeTemplate> persistor = PersistorFactory.Instance.CreateElementNodeTemplatePersistor();
persistor.SaveToFile(elementNodeTemplate, filePath);
}
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;
}
protected TypeSpec(SpecFactory memberFactory, IMetamodelManager metamodelManager, INakedObjectManager nakedObjectManager, ITypeSpecImmutable innerSpec, ISession session, IObjectPersistor persistor)
{
MemberFactory = memberFactory ?? throw new InitialisationException($"{nameof(memberFactory)} is null");
this.metamodelManager = metamodelManager ?? throw new InitialisationException($"{nameof(metamodelManager)} is null");
this.nakedObjectManager = nakedObjectManager ?? throw new InitialisationException($"{nameof(nakedObjectManager)} is null");
this.session = session ?? throw new InitialisationException($"{nameof(session)} is null");
this.persistor = persistor ?? throw new InitialisationException($"{nameof(persistor)} is null");
InnerSpec = innerSpec ?? throw new InitialisationException($"{nameof(innerSpec)} is null");
}
public void SetUp()
{
mockPersistor = new Mock <IObjectPersistor>();
persistor = mockPersistor.Object;
mockManager = new Mock <INakedObjectManager>();
manager = mockManager.Object;
algorithm = new RecursivePersistAlgorithm(persistor, manager);
}
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;
}
public override void Populate(string[] keys,
INakedObjectAdapter nakedObjectAdapter,
INakedObjectManager nakedObjectManager, IDomainObjectInjector injector,
ISession session,
IObjectPersistor persistor)
{
var newVm = populateFunction.Invoke(null, populateFunction.GetParameterValues(nakedObjectAdapter, keys, session, persistor));
nakedObjectAdapter.ReplacePoco(newVm);
}
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;
}
// 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;
}
/// <summary>
/// Factory method to create an an <see cref="InteractionContext" /> to represent
/// <see cref="Architecture.Interactions.InteractionType.MemberAccess" /> reading a property.
/// </summary>
public static InteractionContext AccessMember(ISession session,
IObjectPersistor persistor,
bool programmatic,
INakedObjectAdapter target,
IIdentifier memberIdentifier) =>
new InteractionContext(InteractionType.MemberAccess,
session,
persistor,
programmatic,
target,
memberIdentifier,
null,
null);
/// <summary>
/// Factory method to create an an <see cref="InteractionContext" /> to represent
/// <see cref="Architecture.Interactions.InteractionType.ActionInvoke" /> invoking an action.
/// </summary>
public static InteractionContext InvokingAction(ISession session,
IObjectPersistor persistor,
bool programmatic,
INakedObjectAdapter target,
IIdentifier actionIdentifier,
INakedObjectAdapter[] arguments) =>
new InteractionContext(InteractionType.ActionInvoke,
session,
persistor,
programmatic,
target,
actionIdentifier,
null,
arguments);
public AbstractRootFolder(String source, IObjectPersistor persistor)
: base(null, System.IO.Path.DirectorySeparatorChar.ToString())
{
if (source == null) {
throw new ArgumentNullException("source");
}
if (persistor == null) {
throw new ArgumentNullException("persistor");
}
_source = source;
_persistor = persistor;
}
/// <summary>
/// Factory method to create an an <see cref="InteractionContext" /> to represent
/// <see cref="Architecture.Interactions.InteractionType.PropertyParamModify" /> modifying a property or parameter.
/// </summary>
public static InteractionContext ModifyingPropParam(ISession session,
IObjectPersistor persistor,
bool programmatic,
INakedObjectAdapter target,
IIdentifier propertyIdentifier,
INakedObjectAdapter proposedArgument) =>
new InteractionContext(InteractionType.PropertyParamModify,
session,
persistor,
programmatic,
target,
propertyIdentifier,
proposedArgument,
null);
// 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;
}
// 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;
}
protected internal ActionParameterSpec(IMetamodelManager metamodel, int number, IActionSpec actionSpec, IActionParameterSpecImmutable actionParameterSpecImmutable, INakedObjectManager manager, ISession session, IObjectPersistor persistor)
{
Assert.AssertNotNull(metamodel);
Assert.AssertNotNull(actionSpec);
Assert.AssertNotNull(actionParameterSpecImmutable);
Assert.AssertNotNull(manager);
Assert.AssertNotNull(session);
Assert.AssertNotNull(persistor);
this.metamodel = metamodel;
this.number = number;
parentAction = actionSpec;
this.actionParameterSpecImmutable = actionParameterSpecImmutable;
this.manager = manager;
this.session = session;
this.persistor = persistor;
}
private InteractionContext(InteractionType interactionType,
ISession session,
IObjectPersistor persistor,
bool programmatic,
INakedObjectAdapter target,
IIdentifier id,
INakedObjectAdapter proposedArgument,
INakedObjectAdapter[] arguments)
{
InteractionType = interactionType;
IsProgrammatic = programmatic;
Id = id;
Session = session;
Persistor = persistor;
Target = target;
ProposedArgument = proposedArgument;
ProposedArguments = arguments;
}
public NakedObjectAdapter(IMetamodelManager metamodel, ISession session, IObjectPersistor persistor, ILifecycleManager lifecycleManager, INakedObjectManager nakedObjectManager, object poco, IOid oid)
{
Assert.AssertNotNull(metamodel);
Assert.AssertNotNull(session);
if (poco is INakedObjectAdapter)
{
throw new AdapterException(Log.LogAndReturn($"Adapter can't be used to adapt an adapter: {poco}"));
}
this.metamodel = metamodel;
this.session = session;
this.persistor = persistor;
this.nakedObjectManager = nakedObjectManager;
this.lifecycleManager = lifecycleManager;
this.poco = poco;
Oid = oid;
ResolveState = new ResolveStateMachine(this, session);
version = new NullVersion();
}
public LifeCycleManager(
IMetamodelManager metamodel,
IPersistAlgorithm persistAlgorithm,
IOidGenerator oidGenerator,
IDomainObjectInjector injector,
IObjectPersistor objectPersistor,
INakedObjectManager nakedObjectManager,
ISession session,
ILoggerFactory loggerFactory,
ILogger <LifeCycleManager> logger
)
{
this.metamodel = metamodel ?? throw new InitialisationException($"{nameof(metamodel)} is null");
this.persistAlgorithm = persistAlgorithm ?? throw new InitialisationException($"{nameof(persistAlgorithm)} is null");
this.oidGenerator = oidGenerator ?? throw new InitialisationException($"{nameof(oidGenerator)} is null");
this.injector = injector ?? throw new InitialisationException($"{nameof(injector)} is null");
this.objectPersistor = objectPersistor ?? throw new InitialisationException($"{nameof(objectPersistor)} is null");
this.nakedObjectManager = nakedObjectManager ?? throw new InitialisationException($"{nameof(nakedObjectManager)} is null");
this.session = session;
this.loggerFactory = loggerFactory ?? throw new InitialisationException($"{nameof(loggerFactory)} is null");
this.logger = logger ?? throw new InitialisationException($"{nameof(logger)} is null");
}
public LifeCycleManager(
IMetamodelManager metamodel,
IPersistAlgorithm persistAlgorithm,
IOidGenerator oidGenerator,
IDomainObjectInjector injector,
IObjectPersistor objectPersistor,
INakedObjectManager nakedObjectManager
) {
Assert.AssertNotNull(metamodel);
Assert.AssertNotNull(persistAlgorithm);
Assert.AssertNotNull(oidGenerator);
Assert.AssertNotNull(injector);
Assert.AssertNotNull(objectPersistor);
Assert.AssertNotNull(nakedObjectManager);
this.metamodel = metamodel;
this.persistAlgorithm = persistAlgorithm;
this.oidGenerator = oidGenerator;
this.injector = injector;
this.objectPersistor = objectPersistor;
this.nakedObjectManager = nakedObjectManager;
}
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));
}
public OneToOneAssociationSpec(IMetamodelManager metamodel, IOneToOneAssociationSpecImmutable association, ISession session, ILifecycleManager lifecycleManager, INakedObjectManager manager, IObjectPersistor persistor, ITransactionManager transactionManager)
: base(metamodel, association, session, lifecycleManager, manager)
{
this.persistor = persistor;
this.transactionManager = transactionManager;
}
public FlatPersistAlgorithm(IObjectPersistor persistor, INakedObjectManager manager) {
this.persistor = persistor;
this.manager = manager;
}
public OneToOneAssociationSpec(IMetamodelManager metamodel, IOneToOneAssociationSpecImmutable association, ISession session, ILifecycleManager lifecycleManager, INakedObjectManager manager, IObjectPersistor persistor, ITransactionManager transactionManager)
: base(metamodel, association, session, lifecycleManager, manager) {
this.persistor = persistor;
this.transactionManager = transactionManager;
}
public ActionParseableParameterSpec(IMetamodelManager metamodel, int index, IActionSpec actionSpec, IActionParameterSpecImmutable actionParameterSpecImmutable, INakedObjectManager manager, ISession session, IObjectPersistor persistor)
: base(metamodel, index, actionSpec, actionParameterSpecImmutable, manager, session, persistor) {}
public GenericRootFolder(String source, IObjectPersistor persistor)
: base(source, persistor)
{
}
