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