public IEnumerable GetBoundedSet(IObjectSpec spec)
{
if (spec.IsBoundedSet())
{
if (spec.IsInterface)
{
IList <object> instances = new List <object>();
// ReSharper disable once LoopCanBeConvertedToQuery
// LINQ needs cast - need to be careful with EF - safest to leave as loop
foreach (var subSpec in GetLeafNodes(spec))
{
foreach (var instance in Instances((IObjectSpec)subSpec))
{
instances.Add(instance);
}
}
return(instances);
}
return(Instances(spec));
}
return(new object[] { });
}
private INakedObject GetValue(IObjectSpec specification, object rawValue) {
if (rawValue == null) {
return null;
}
if (specification.IsParseable) {
return specification.GetFacet<IParseableFacet>().ParseTextEntry(rawValue.ToString(), framework.NakedObjectManager);
}
var no = framework.NakedObjectManager.CreateAdapter(rawValue, null, null);
// the rawValue is not necessarily a collection so need extra check here to avoid
// a potential error getting the element spec.
if (specification.IsCollection && (no.Spec.IsCollection && !no.Spec.IsParseable)) {
var elementSpec = specification.GetFacet<ITypeOfFacet>().GetValueSpec(no, framework.MetamodelManager.Metamodel);
if (elementSpec.IsParseable) {
var elements = ((IEnumerable) rawValue).Cast<object>().Select(e => elementSpec.GetFacet<IParseableFacet>().ParseTextEntry(e.ToString(), framework.NakedObjectManager)).ToArray();
var elementType = TypeUtils.GetType(elementSpec.FullName);
Type collType = typeof (List<>).MakeGenericType(elementType);
var collection = framework.NakedObjectManager.CreateAdapter(Activator.CreateInstance(collType), null, null);
collection.Spec.GetFacet<ICollectionFacet>().Init(collection, elements);
return collection;
}
}
return no;
}
public INakedObjectAdapter LoadObject(IOid oid, IObjectSpec spec)
{
Assert.AssertNotNull("needs an OID", oid);
Assert.AssertNotNull("needs a specification", spec);
return(objectStore.GetObject(oid, spec));
}
public INakedObjectAdapter CreateViewModel(IObjectSpec spec) {
Log.DebugFormat("CreateViewModel of: {0}", spec);
object viewModel = CreateObject(spec);
INakedObjectAdapter adapter = nakedObjectManager.CreateViewModelAdapter(spec, viewModel);
InitializeNewObject(adapter);
return adapter;
}
public INakedObjectAdapter CreateViewModelAdapter(IObjectSpec spec, object viewModel)
{
var adapter = CreateAdapterForViewModel(viewModel, spec);
adapter.ResolveState.Handle(Events.InitializePersistentEvent);
return(adapter);
}
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 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);
}
public static INakedObjectAdapter GetTypedCollection(this INakedObjectsFramework framework, ISpecification featureSpec, IEnumerable collectionValue)
{
IObjectSpec collectionitemSpec = framework.MetamodelManager.GetSpecification(featureSpec.GetFacet <IElementTypeFacet>().ValueSpec);
string[] rawCollection = collectionValue.Cast <string>().ToArray();
object[] objCollection;
Type instanceType = TypeUtils.GetType(collectionitemSpec.FullName);
var typedCollection = (IList)Activator.CreateInstance(typeof(List <>).MakeGenericType(instanceType));
if (collectionitemSpec.IsParseable)
{
objCollection = rawCollection.Select(s => string.IsNullOrEmpty(s) ? null : collectionitemSpec.GetFacet <IParseableFacet>().ParseTextEntry(s, framework.NakedObjectManager).Object).ToArray();
}
else
{
// need to check if collection is actually a collection memento
if (rawCollection.Count() == 1)
{
INakedObjectAdapter firstObj = framework.GetNakedObjectFromId(rawCollection.First());
if (firstObj != null && firstObj.Oid is ICollectionMemento)
{
return(firstObj);
}
}
objCollection = rawCollection.Select(s => framework.GetNakedObjectFromId(s).GetDomainObject()).ToArray();
}
objCollection.Where(o => o != null).ForEach(o => typedCollection.Add(o));
return(framework.NakedObjectManager.CreateAdapter(typedCollection.AsQueryable(), null, null));
}
public ViewModelOid(IMetamodelManager metamodel, IObjectSpec spec) {
Assert.AssertNotNull(metamodel);
this.metamodel = metamodel;
IsTransient = false;
TypeName = TypeNameUtils.EncodeTypeName(spec.FullName);
Keys = new[] {Guid.NewGuid().ToString()};
CacheState();
}
public ViewModelOid(IMetamodelManager metamodel, IObjectSpec spec)
{
this.metamodel = metamodel ?? throw new InitialisationException($"{nameof(metamodel)} is null");
IsTransient = false;
TypeName = TypeNameUtils.EncodeTypeName(spec.FullName);
Keys = new[] { Guid.NewGuid().ToString() };
CacheState();
}
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);
}
public INakedObjectAdapter CreateViewModel(IObjectSpec spec)
{
object viewModel = CreateObject(spec);
INakedObjectAdapter adapter = nakedObjectManager.CreateViewModelAdapter(spec, viewModel);
InitializeNewObject(adapter);
return(adapter);
}
public static string CollectionTitleString(IObjectSpec elementSpec, int size)
{
if (elementSpec == null || elementSpec.FullName.Equals(typeof(object).FullName))
{
return(CollectionTitleStringUnknownType(size));
}
return(CollectionTitleStringKnownType(elementSpec, size));
}
private static string CollectionTitleStringKnownType(IObjectSpec elementSpec, int size)
{
return(size switch {
IncompleteCollection => string.Format(Resources.NakedObjects.CollectionTitleUnloaded, elementSpec.PluralName),
0 => string.Format(Resources.NakedObjects.CollectionTitleEmpty, elementSpec.PluralName),
1 => string.Format(Resources.NakedObjects.CollectionTitleOne, elementSpec.SingularName),
_ => string.Format(Resources.NakedObjects.CollectionTitleMany, size, elementSpec.PluralName)
});
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 INakedObjectAdapter CreateViewModel(IObjectSpec spec)
{
Log.DebugFormat("CreateViewModel of: {0}", spec);
object viewModel = CreateObject(spec);
INakedObjectAdapter adapter = nakedObjectManager.CreateViewModelAdapter(spec, viewModel);
InitializeNewObject(adapter);
return(adapter);
}
public ViewModelOid(IMetamodelManager metamodel, IObjectSpec spec)
{
Assert.AssertNotNull(metamodel);
this.metamodel = metamodel;
IsTransient = false;
TypeName = TypeNameUtils.EncodeTypeName(spec.FullName);
Keys = new[] { Guid.NewGuid().ToString() };
CacheState();
}
/// <summary>
/// Factory (for transient instance)
/// </summary>
public INakedObjectAdapter CreateInstance(IObjectSpec spec) {
if (spec.ContainsFacet(typeof (IComplexTypeFacet))) {
throw new TransientReferenceException(Log.LogAndReturn(Resources.NakedObjects.NoTransientInline));
}
object obj = CreateObject(spec);
INakedObjectAdapter adapter = nakedObjectManager.CreateInstanceAdapter(obj);
InitializeNewObject(adapter);
return adapter;
}
public INakedObject LoadObject(IOid oid, IObjectSpec spec)
{
Log.DebugFormat("LoadObject oid: {0} specification: {1}", oid, spec);
Assert.AssertNotNull("needs an OID", oid);
Assert.AssertNotNull("needs a specification", spec);
return(objectStore.GetObject(oid, spec));
}
private ObjectContextSurface CreateObject(string typeName, ArgumentsContext arguments) {
if (string.IsNullOrWhiteSpace(typeName)) {
throw new BadRequestNOSException();
}
IObjectSpec spec = (IObjectSpec) GetDomainTypeInternal(typeName);
INakedObject nakedObject = framework.LifecycleManager.CreateInstance(spec);
return SetObject(nakedObject, arguments);
}
private ListContext GetServicesInternal() {
INakedObject[] services = framework.ServicesManager.GetServicesWithVisibleActions(ServiceType.Menu | ServiceType.Contributor, framework.LifecycleManager);
IObjectSpec elementType = (IObjectSpec) framework.MetamodelManager.GetSpecification(typeof (object));
return new ListContext {
ElementType = elementType,
List = services,
IsListOfServices = true
};
}
private ITestObject GetBoundedInstance(string title, IObjectSpec spec)
{
if (spec.GetFacet <IBoundedFacet>() == null)
{
Assert.Fail(spec.SingularName + " is not a Bounded type");
}
IEnumerable allInstances = NakedObjectsFramework.Persistor.Instances(spec);
var inst = allInstances.Cast <object>().Single(o => NakedObjectsFramework.NakedObjectManager.CreateAdapter(o, null, null).TitleString() == title);
return(TestObjectFactoryClass.CreateTestObject(NakedObjectsFramework.NakedObjectManager.CreateAdapter(inst, null, null)));
}
/// <summary>
/// Factory (for transient instance)
/// </summary>
public INakedObjectAdapter CreateInstance(IObjectSpec spec)
{
if (spec.ContainsFacet(typeof(IComplexTypeFacet)))
{
throw new TransientReferenceException(Log.LogAndReturn(Resources.NakedObjects.NoTransientInline));
}
object obj = CreateObject(spec);
INakedObjectAdapter adapter = nakedObjectManager.CreateInstanceAdapter(obj);
InitializeNewObject(adapter);
return(adapter);
}
/// <summary>
/// Factory (for transient instance)
/// </summary>
public virtual INakedObject CreateInstance(IObjectSpec spec)
{
Log.DebugFormat("CreateInstance of: {0}", spec);
if (spec.ContainsFacet(typeof(IComplexTypeFacet)))
{
throw new TransientReferenceException(Resources.NakedObjects.NoTransientInline);
}
object obj = CreateObject(spec);
INakedObject adapter = nakedObjectManager.CreateInstanceAdapter(obj);
InitializeNewObject(adapter);
return(adapter);
}
private INakedObjectAdapter GetViewModel(string[] keys, IObjectSpec spec)
{
try {
INakedObjectAdapter viewModel = framework.LifecycleManager.CreateViewModel(spec);
spec.GetFacet <IViewModelFacet>().Populate(keys, viewModel, framework.NakedObjectManager, framework.DomainObjectInjector);
return(viewModel);
}
catch (Exception e) {
Log.Warn("View Model not found with exception", e);
Log.WarnFormat("View Model not found keys: {0} type: {1}", keys == null ? "null" : keys.Aggregate("", (s, t) => s + " " + t), spec == null ? "null" : spec.FullName);
return(null);
}
}
public INakedObjectAdapter LoadObject(IOid oid, IObjectSpec spec)
{
if (oid == null)
{
throw new NakedObjectSystemException(logger.LogAndReturn("needs an OID"));
}
if (spec == null)
{
throw new NakedObjectSystemException(logger.LogAndReturn("needs a specification"));
}
return(objectStore.GetObject(oid, spec));
}
private INakedObjectAdapter CreateAdapterForViewModel(object viewModel, IObjectSpec spec)
{
var oid = new ViewModelOid(metamodel, spec);
INakedObjectAdapter adapter = NewAdapterForKnownObject(viewModel, oid);
object versionObject = adapter.GetVersion(this);
if (versionObject != null)
{
adapter.OptimisticLock = new ConcurrencyCheckVersion(session.UserName, DateTime.Now, versionObject);
}
identityMap.AddAdapter(adapter);
return(adapter);
}
public void CachedObjectsOfType()
{
Claim claim1 = NakedObjectsFramework.Persistor.Instances <Claim>().OrderBy(c => c.Id).First();
Claim claim2 = NakedObjectsFramework.Persistor.Instances <Claim>().OrderByDescending(c => c.Id).First();
mocks.HtmlHelper.ViewContext.HttpContext.Session.AddToCache(NakedObjectsFramework, claim1);
mocks.HtmlHelper.ViewContext.HttpContext.Session.AddToCache(NakedObjectsFramework, claim2);
IObjectSpec spec = (IObjectSpec)NakedObjectsFramework.MetamodelManager.GetSpecification(typeof(Claim));
Assert.IsTrue(mocks.HtmlHelper.ViewContext.HttpContext.Session.CachedObjectsOfType(NakedObjectsFramework, spec).Contains(claim1));
Assert.IsTrue(mocks.HtmlHelper.ViewContext.HttpContext.Session.CachedObjectsOfType(NakedObjectsFramework, spec).Contains(claim2));
Assert.IsTrue(mocks.HtmlHelper.ViewContext.HttpContext.Session.CachedObjectsOfType(NakedObjectsFramework, spec).Count() == 2);
}
public void CachedObjectsOfDifferentType()
{
GeneralExpense item1 = NakedObjectsFramework.Persistor.Instances <GeneralExpense>().OrderBy(c => c.Id).First();
GeneralExpense item2 = NakedObjectsFramework.Persistor.Instances <GeneralExpense>().OrderByDescending(c => c.Id).First();
mocks.HtmlHelper.ViewContext.HttpContext.Session.AddToCache(NakedObjectsFramework, item1);
mocks.HtmlHelper.ViewContext.HttpContext.Session.AddToCache(NakedObjectsFramework, item2);
IObjectSpec spec = (IObjectSpec)NakedObjectsFramework.MetamodelManager.GetSpecification(typeof(Claim));
Assert.IsFalse(mocks.HtmlHelper.ViewContext.HttpContext.Session.CachedObjectsOfType(NakedObjectsFramework, spec).Contains(item1));
Assert.IsFalse(mocks.HtmlHelper.ViewContext.HttpContext.Session.CachedObjectsOfType(NakedObjectsFramework, spec).Contains(item2));
Assert.IsTrue(!mocks.HtmlHelper.ViewContext.HttpContext.Session.CachedObjectsOfType(NakedObjectsFramework, spec).Any());
}
private Tuple<IAssociationSpec, IObjectSpec> GetPropertyTypeInternal(string typeName, string propertyName) {
if (string.IsNullOrWhiteSpace(typeName) || string.IsNullOrWhiteSpace(propertyName)) {
throw new BadRequestNOSException();
}
IObjectSpec spec = (IObjectSpec) GetDomainTypeInternal(typeName);
IAssociationSpec property = spec.Properties.SingleOrDefault(p => p.Id == propertyName);
if (property == null) {
throw new TypePropertyResourceNotFoundNOSException(propertyName, typeName);
}
return new Tuple<IAssociationSpec, IObjectSpec>(property, (IObjectSpec) spec);
}
private INakedObject CreateAdapterForViewModel(object viewModel, IObjectSpec spec)
{
var oid = new ViewModelOid(metamodel, spec);
INakedObject adapter = NewAdapterForKnownObject(viewModel, oid);
object versionObject = adapter.GetVersion(this);
if (versionObject != null)
{
adapter.OptimisticLock = new ConcurrencyCheckVersion(session.UserName, DateTime.Now, versionObject);
Log.DebugFormat("CreateAdapterForViewModel: Updating Version {0} on {1}", adapter.Version, adapter);
}
Log.DebugFormat("Creating adapter (ViewModel) {0}", adapter);
identityMap.AddAdapter(adapter);
return(adapter);
}
private static string CollectionTitleStringKnownType(IObjectSpec elementSpec, int size)
{
switch (size)
{
case IncompleteCollection:
return(string.Format(Resources.NakedObjects.CollectionTitleUnloaded, elementSpec.PluralName));
case 0:
return(string.Format(Resources.NakedObjects.CollectionTitleEmpty, elementSpec.PluralName));
case 1:
return(string.Format(Resources.NakedObjects.CollectionTitleOne, elementSpec.SingularName));
default:
return(string.Format(Resources.NakedObjects.CollectionTitleMany, size, elementSpec.PluralName));
}
}
private static IResolveStateMachine NewSm()
{
var mockAdapter = new Mock <INakedObjectAdapter>();
INakedObjectAdapter testAdapter = mockAdapter.Object;
var mockSpecification = new Mock <IObjectSpec>();
IObjectSpec testSpecification = mockSpecification.Object;
var mockFacet = new Mock <ITestCallbackFacet>();
ITestCallbackFacet testFacet = mockFacet.Object;
mockFacet.Setup(f => f.Invoke(null, null, null, null));
mockAdapter.Setup(a => a.Spec).Returns(testSpecification);
mockSpecification.Setup(s => s.GetFacet(null)).Returns(testFacet);
mockSpecification.Setup(s => s.GetFacet <ILoadingCallbackFacet>()).Returns(testFacet);
mockSpecification.Setup(s => s.GetFacet <ILoadedCallbackFacet>()).Returns(testFacet);
return(new ResolveStateMachine(testAdapter, null));
}
private INakedObject[] GetConditionalList(INakedObject nakedObject, ArgumentsContext arguments) {
Tuple<string, IObjectSpec>[] expectedParms = GetChoicesParameters();
IDictionary<string, object> actualParms = arguments.Values;
string[] expectedParmNames = expectedParms.Select(t => t.Item1).ToArray();
string[] actualParmNames = actualParms.Keys.ToArray();
if (expectedParmNames.Count() < actualParmNames.Count()) {
throw new BadRequestNOSException("Wrong number of conditional arguments");
}
if (!actualParmNames.All(expectedParmNames.Contains)) {
throw new BadRequestNOSException("Unrecognised conditional argument(s)");
}
Func<Tuple<string, IObjectSpec>, object> getValue = ep => {
if (actualParms.ContainsKey(ep.Item1)) {
return actualParms[ep.Item1];
}
return ep.Item2.IsParseable ? "" : null;
};
var matchedParms = expectedParms.ToDictionary(ep => ep.Item1, ep => new {
expectedType = ep.Item2,
value = getValue(ep),
actualType = getValue(ep) == null ? null : framework.MetamodelManager.GetSpecification(getValue(ep).GetType())
});
var errors = new List<ContextSurface>();
var mappedArguments = new Dictionary<string, INakedObject>();
foreach (var ep in expectedParms) {
string key = ep.Item1;
var mp = matchedParms[key];
object value = mp.value;
IObjectSpec expectedType = mp.expectedType;
ITypeSpec actualType = mp.actualType;
if (expectedType.IsParseable && actualType.IsParseable) {
string rawValue = value.ToString();
try {
mappedArguments[key] = expectedType.GetFacet<IParseableFacet>().ParseTextEntry(rawValue, framework.NakedObjectManager);
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
ProposedValue = rawValue
});
}
catch (Exception e) {
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
Reason = e.Message,
ProposedValue = rawValue
});
}
}
else if (actualType != null && !actualType.IsOfType(expectedType)) {
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
Reason = string.Format("Argument is of wrong type is {0} expect {1}", actualType.FullName, expectedType.FullName),
ProposedValue = actualParms[ep.Item1]
});
}
else {
mappedArguments[key] = framework.NakedObjectManager.CreateAdapter(value, null, null);
errors.Add(new ChoiceContextSurface(key, GetSpecificationWrapper(expectedType)) {
ProposedValue = getValue(ep)
});
}
}
if (errors.Any(e => !string.IsNullOrEmpty(e.Reason))) {
throw new BadRequestNOSException("Wrong type of conditional argument(s)", errors);
}
return GetChoices(nakedObject, mappedArguments);
}
private INakedObjectSpecificationSurface GetSpecificationWrapper(IObjectSpec spec) {
return new NakedObjectSpecificationWrapper(spec, surface, framework);
}
public INakedObjectAdapter CreateViewModelAdapter(IObjectSpec spec, object viewModel) {
INakedObjectAdapter adapter = CreateAdapterForViewModel(viewModel, spec);
adapter.ResolveState.Handle(Events.InitializePersistentEvent);
return adapter;
}
private INakedObjectAdapter CreateAdapterForViewModel(object viewModel, IObjectSpec spec) {
var oid = new ViewModelOid(metamodel, spec);
INakedObjectAdapter adapter = NewAdapterForKnownObject(viewModel, oid);
object versionObject = adapter.GetVersion(this);
if (versionObject != null) {
adapter.OptimisticLock = new ConcurrencyCheckVersion(session.UserName, DateTime.Now, versionObject);
}
identityMap.AddAdapter(adapter);
return adapter;
}
private IObjectSpecImmutable GetImmutableSpec(IObjectSpec spec) {
return Framework.MetamodelManager.Metamodel.GetSpecification(spec.FullName) as IObjectSpecImmutable;
}
private INakedObjectAdapter GetViewModel(string[] keys, IObjectSpec spec) {
try {
INakedObjectAdapter viewModel = framework.LifecycleManager.CreateViewModel(spec);
spec.GetFacet<IViewModelFacet>().Populate(keys, viewModel, framework.NakedObjectManager, framework.DomainObjectInjector);
return viewModel;
}
catch (Exception e) {
Log.Warn("View Model not found with exception", e);
Log.WarnFormat("View Model not found keys: {0} type: {1}", keys == null ? "null" : keys.Aggregate("", (s, t) => s + " " + t), spec == null ? "null" : spec.FullName);
return null;
}
}
public static bool IsCollectionOfBoundedSet(this ITypeSpec spec, IObjectSpec elementSpec) {
return spec.IsCollection && elementSpec.IsBoundedSet();
}
public static bool IsCollectionOfEnum(this ITypeSpec spec, IObjectSpec elementSpec) {
return spec.IsCollection && elementSpec.ContainsFacet<IEnumFacet>();
}
public INakedObjectAdapter CreateViewModel(IObjectSpec spec) {
object viewModel = CreateObject(spec);
INakedObjectAdapter adapter = nakedObjectManager.CreateViewModelAdapter(spec, viewModel);
InitializeNewObject(adapter);
return adapter;
}
