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));
        }
 private static INakedObject SafeGetNakedObjectFromId(string id, INakedObjectsFramework framework)
 {
     try {
         return(framework.GetNakedObjectFromId(id));
     }
     catch (Exception) {
         // create a NakedObject just to carry the 'Destroyed' state
         var no = framework.GetNakedObject(new object());
         no.ResolveState.Handle(Events.StartResolvingEvent);
         no.ResolveState.Handle(Events.DestroyEvent);
         return(no);
     }
 }
        public INakedObject GetNakedObject(INakedObjectsFramework framework)
        {
            if (nakedObject == null)
            {
                nakedObject = framework.GetNakedObjectFromId(Id);
            }

            if (nakedObject == null)
            {
                throw new ObjectNotFoundException();
            }

            return(nakedObject);
        }
 public static object GetObjectFromId(this INakedObjectsFramework framework, string encodedId)
 {
     return(framework.GetNakedObjectFromId(encodedId).Object);
 }
 private static IEnumerable <INakedObject> GetAndTidyCachedNakedObjectsOfType(this HttpSessionStateBase session, INakedObjectsFramework framework, ITypeSpec spec, ObjectFlag flag)
 {
     session.ClearDestroyedObjectsOfType(framework, spec, flag);
     return(session.GetCache(flag).Where(cm => SameSpec(cm.Value.Spec, spec, framework)).OrderBy(kvp => kvp.Value.Added).Select(kvp => framework.GetNakedObjectFromId(kvp.Key)));
 }
 // This is dangerous - retrieves all cached objects from the database - use with care !
 private static IEnumerable <INakedObject> GetAndTidyCachedNakedObjects(this HttpSessionStateBase session, INakedObjectsFramework framework, ObjectFlag flag)
 {
     session.ClearDestroyedObjects(framework, flag);
     return(session.GetCache(flag).OrderBy(kvp => kvp.Value.Added).Select(kvp => framework.GetNakedObjectFromId(kvp.Key)));
 }