public virtual void Add(IOid oid, INakedObject adapter) {
     lock (adapters) {
         adapters[oid] = adapter;
     }
     // log after so that adapter is in map if required by ToString
     Log.DebugFormat("Add {0} as {1}", oid, adapter);
 }
Esempio n. 2
0
 public static object Invoke(MethodInfo method, INakedObject nakedObject, INakedObject[] parameters) {
     object[] parameterPocos = parameters == null ? new object[0] : new object[parameters.Length];
     for (int i = 0; i < parameterPocos.Length; i++) {
         parameterPocos[i] = parameters[i] == null ? null : parameters[i].Object;
     }
     return Invoke(method, nakedObject.Object, parameterPocos);
 }
Esempio n. 3
0
        private void Page(ICollectionFacet testArrayFacet, INakedObject collection, object first) {
            INakedObject pagedCollection = testArrayFacet.Page(1, 1, collection, false);
            var pagedCollectionFacet = new DotNetGenericIEnumerableFacet<object>(facetHolder, typeof (object), false);

            Assert.IsTrue(pagedCollectionFacet.AsEnumerable(pagedCollection).Count() == 1);
            Assert.AreSame(pagedCollectionFacet.AsEnumerable(pagedCollection).First().Object, first);
        }
        protected void Persist(INakedObject nakedObject, IPersistedObjectAdder persistor) {
            if (nakedObject.ResolveState.IsAggregated() ||
                (nakedObject.ResolveState.IsTransient() &&
                 nakedObject.Specification.Persistable != Persistable.TRANSIENT)) {
                INakedObjectAssociation[] fields = nakedObject.Specification.Properties;
                if (!nakedObject.Specification.IsEncodeable && fields.Length > 0) {
                    Log.Info("make persistent " + nakedObject);
                    nakedObject.Persisting();
                    if (!nakedObject.Specification.ContainsFacet(typeof (IComplexTypeFacet))) {
                        persistor.MadePersistent(nakedObject);
                    }

                    foreach (INakedObjectAssociation field in fields) {
                        if (!field.IsPersisted) {
                            continue;
                        }
                        if (field is IOneToManyAssociation) {
                            INakedObject collection = field.GetNakedObject(nakedObject);
                            if (collection == null) {
                                throw new NotPersistableException("Collection " + field.Name + " does not exist in " + nakedObject.Specification.FullName);
                            }
                            MakePersistent(collection, persistor);
                        }
                        else {
                            INakedObject fieldValue = field.GetNakedObject(nakedObject);
                            if (fieldValue == null) {
                                continue;
                            }
                            Persist(fieldValue, persistor);
                        }
                    }
                    persistor.AddPersistedObject(nakedObject);
                }
            }
        }
 public virtual void Add(object obj, INakedObject adapter) {
     lock (domainObjects) {
         domainObjects[obj] = adapter;
     }
     // log at end so that if ToString needs adapters they're in maps. 
     Log.DebugFormat("Add instance of {0} as {1}", obj.GetType().FullName, adapter);
 }
Esempio n. 6
0
 private static void ClearPreviousTransients(this HttpSessionStateBase session, INakedObject nakedObject, ObjectFlag flag) {
     if (nakedObject.Oid.HasPrevious) {
         if (nakedObject.Oid.Previous.IsTransient) {
             session.GetCache(flag).Remove(FrameworkHelper.GetObjectId(nakedObject.Oid.Previous));
         }
     }
 }
 public override string HiddenReason(INakedObject nakedObject) {
     if (nakedObject == null) {
         return null;
     }
     var isHidden = (bool) InvokeUtils.Invoke(method, nakedObject);
     return isHidden ? Resources.NakedObjects.Hidden : null;
 }
 public void MakePersistent(INakedObject nakedObject, IPersistedObjectAdder persistor) {
     if (nakedObject.Specification.IsCollection) {
         MakeCollectionPersistent(nakedObject, persistor);
     }
     else {
         MakeObjectPersistent(nakedObject, persistor);
     }
 }
 private INamespaceAuditor GetNamespaceAuthorizerFor(INakedObject target) {
     Assert.AssertNotNull(target);
     string fullyQualifiedOfTarget = target.Specification.FullName;
     return namespaceAuditors.
         Where(x => fullyQualifiedOfTarget.StartsWith(x.NamespaceToAudit)).
         OrderByDescending(x => x.NamespaceToAudit.Length).
         FirstOrDefault();
 }
 public virtual void AddDisposedObject(INakedObject nakedObject) {
     lock (disposals) {
         Log.DebugFormat("Mark as disposed {0}", nakedObject);
         if (!disposals.Contains(nakedObject)) {
             disposals.Add(nakedObject);
         }
     }
 }
 /// <summary>
 ///     Whether the provided argument exceeds the <see cref="SingleIntValueFacetAbstract.Value" /> maximum length}.
 /// </summary>
 public virtual bool Exceeds(INakedObject nakedObject) {
     string str = UnwrapString(nakedObject);
     if (str == null) {
         return false;
     }
     int maxLength = Value;
     return maxLength != 0 && str.Length > maxLength;
 }
Esempio n. 12
0
        public static void AddOrUpdateInCache(this HttpSessionStateBase session, INakedObject nakedObject, string url, ObjectFlag flag = ObjectFlag.None) {
            // only add transients if we are storing transients in the session 

            if ((!nakedObject.ResolveState.IsTransient() || MvcIdentityAdapterHashMap.StoringTransientsInSession) || nakedObject.Specification.IsCollection) {
                session.ClearPreviousTransients(nakedObject, flag);
                session.GetCache(flag).AddOrUpdateInCache(nakedObject, url, flag);
            }
        }
 public override void SetProperty(INakedObject nakedObject, INakedObject value) {
     try {
         property.SetValue(nakedObject.GetDomainObject(), value.GetDomainObject(), null);
     }
     catch (TargetInvocationException e) {
         InvokeUtils.InvocationException("Exception executing " + property, e);
     }
 }
Esempio n. 14
0
        public void SetUp() {
            IFacetHolder holder = null;
            Customer17 customer = new Customer17();
            target = new ProgrammableNakedObject(customer, null);

            MethodInfo method = typeof(Customer17).GetMethod("Validate0SomeAction");
            facet = new ActionParameterValidationFacetViaMethod(method, 0, holder);
        }
Esempio n. 15
0
 public override string InvalidReason(INakedObject target, INakedObject proposedValue) {
     if (proposedValue != null) {
         return (string) InvokeUtils.Invoke(method, target, new[] {proposedValue});
     }
     else {
         return null;
     }
 }
 public virtual void AddChangedObject(INakedObject nakedObject) {
     lock (changes) {
         Log.DebugFormat("Mark as dirty {0}", nakedObject);
         if (!changes.Contains(nakedObject)) {
             changes.Add(nakedObject);
         }
     }
 }
        public override bool IsEditView(INakedObject nakedObject) {
            var target = nakedObject.GetDomainObject<IViewModelSwitchable>();

            if (target != null) {
                return target.IsEditView();
            }

            throw new NakedObjectSystemException(nakedObject.Object == null ? "Null domain object" : "Wrong type of domain object: " + nakedObject.Object.GetType().FullName);
        }
 public override void AddAdapter(INakedObject nakedObject) {
     base.AddAdapter(nakedObject);
     if (nakedObject.Specification.IsService ||
         nakedObject.Specification.IsViewModel ||
         nakedObject.Specification.ContainsFacet(typeof (IComplexTypeFacet))) {
         return;
     }
     ObjectStore.LoadComplexTypes(nakedObject, nakedObject.ResolveState.IsGhost());
 }
        public override void Init(INakedObject collection, INakedObject[] initData) {
            IList wrappedCollection = AsCollection(collection);

            List<object> toAdd = initData.Select(no => no.Object).Where(obj => !wrappedCollection.Contains(obj)).ToList();
            toAdd.ForEach(obj => wrappedCollection.Add(obj));

            List<object> toRemove = wrappedCollection.Cast<object>().Where(o => !initData.Select(x => x.Object).Contains(o)).ToList();
            toRemove.ForEach(wrappedCollection.Remove);
        }
        public CollectionMemento(INakedObject target, INakedObjectAction action, INakedObject[] parameters) {
            Target = target;
            Action = action;
            Parameters = parameters;

            if (Target.Specification.IsViewModel) {
                PersistorUtils.PopulateViewModelKeys(Target);
            }
        }
 private IEnumerable PageInternal(int page, int size, INakedObject collection) {
     int firstIndex = (page - 1)*size;
     for (int index = firstIndex; index < firstIndex + size; index++) {
         if (index >= AsEnumerable(collection).Count()) {
             yield break;
         }
         yield return AsCollection(collection)[index];
     }
 }
        public override void Init(INakedObject collection, INakedObject[] initData) {
            Array newCollection = Array.CreateInstance(collection.GetDomainObject().GetType().GetElementType(), initData.Length);
            collection.ReplacePoco(newCollection);

            int i = 0;
            foreach (INakedObject nakedObject in initData) {
                AsCollection(collection)[i++] = nakedObject.Object;
            }
        }
 public override object GetProperty(INakedObject nakedObject) {
     try {
         return propertyMethod.GetValue(nakedObject.GetDomainObject(), null);
     }
     catch (TargetInvocationException e) {
         InvokeUtils.InvocationException("Exception executing " + propertyMethod, e);
         return null;
     }
 }
        public bool IsVisible(ISession session, INakedObject target, IIdentifier member) {
            var checkViewType = member.IsField ? CheckType.ViewField : CheckType.Action;
            var checkEditType = member.IsField ? CheckType.EditField : CheckType.Action;

            var contextView = new AuthorizationContext((ClaimsPrincipal)session.Principal, member.ToIdentityString(IdentifierDepth.ClassName), ((int)checkViewType).ToString());
            var contextEdit = new AuthorizationContext((ClaimsPrincipal)session.Principal, member.ToIdentityString(IdentifierDepth.ClassName), ((int)checkEditType).ToString());

            // being editable implies visibility 
            return manager.CheckAccess(contextView) || manager.CheckAccess(contextEdit);
        }
 public static void MakeObjectPersistent(INakedObject nakedObject, IPersistedObjectAdder persistor) {
     if (nakedObject.ResolveState.IsAggregated() ||
         nakedObject.ResolveState.IsPersistent() ||
         nakedObject.Specification.Persistable == Persistable.TRANSIENT ||
         nakedObject.Specification.IsService) {
         return;
     }
     Log.Info("persist " + nakedObject);
     persistor.AddPersistedObject(nakedObject);
 }
 public void Reset(INakedObject inObject) {
     try {
         var collection = (IList) property.GetValue(inObject.GetDomainObject(), null);
         collection.Clear();
         property.SetValue(inObject.GetDomainObject(), collection, null);
     }
     catch (Exception e) {
         throw new ReflectionException(string.Format("Failed to get/set property {0} in {1}", property.Name, inObject.Specification.FullName), e);
     }
 }
        public override INakedObject Invoke(INakedObject inObject, INakedObject[] parameters) {
            if (parameters.Length != paramCount) {
                Log.Error(actionMethod + " requires " + paramCount + " parameters, not " + parameters.Length);
            }

            object result = InvokeUtils.Invoke(actionMethod, inObject, parameters);
            INakedObject adaptedResult = PersistorUtils.CreateAdapter(result);

            Log.DebugFormat("Action result {0}", adaptedResult);
            return adaptedResult;
        }
        public void Invoke(INakedObject nakedObject, INakedObject[] parameters, bool queryOnly, IIdentifier identifier) {
            Init();
            IAuditor auditor = GetNamespaceAuthorizerFor(nakedObject) ?? defaultAuditor;

            if (nakedObject.Specification.IsService) {
                string serviceName = nakedObject.Specification.GetTitle(nakedObject);
                auditor.ActionInvoked(NakedObjectsContext.Session.Principal, identifier.MemberName, serviceName, queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
            else {
                auditor.ActionInvoked(NakedObjectsContext.Session.Principal, identifier.MemberName, nakedObject.GetDomainObject(), queryOnly, parameters.Select(no => no.GetDomainObject()).ToArray());
            }
        }
 private void MakeCollectionPersistent(INakedObject collection, IPersistedObjectAdder persistor) {
     if (collection.ResolveState.IsPersistent() || collection.Specification.Persistable == Persistable.TRANSIENT) {
         return;
     }
     Log.Info("persist " + collection);
     if (collection.ResolveState.IsTransient()) {
         collection.ResolveState.Handle(Events.StartResolvingEvent);
         collection.ResolveState.Handle(Events.EndResolvingEvent);
     }
     persistor.MadePersistent(collection);
     collection.GetAsEnumerable().ForEach(no => MakePersistent(no, persistor));
 }
Esempio n. 30
0
        private static string GetFieldInputId(INakedObject nakedObject, INakedObjectAssociation property) {
            string fieldId;

            if (nakedObject.Oid is AggregateOid) {
                var aoid = ((AggregateOid) nakedObject.Oid);
                INakedObjectAssociation parent = aoid.ParentOid.Specification.Properties.Where(p => p.Id == aoid.FieldName).SingleOrDefault();
                fieldId = IdHelper.GetInlineFieldInputId(parent, nakedObject, property);
            }
            else {
                fieldId = IdHelper.GetFieldInputId(nakedObject, property);
            }
            return fieldId;
        }
 public TimeSpan TimeValue(INakedObject nakedObject)
 {
     return(nakedObject.GetDomainObject <TimeSpan>());
 }
Esempio n. 32
0
 public string Validate(INakedObject nakedObject)
 {
     return(null);
 }
 public override void Invoke(INakedObject nakedObject, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager)
 {
     InvokeUtils.Invoke(method, nakedObject);
 }
Esempio n. 34
0
 public static IActionSpec[] GetActionLeafNodes(this INakedObject nakedObject)
 {
     return(nakedObject.Spec.GetActionLeafNodes());
 }
Esempio n. 35
0
        public override IConsent IsUsable(INakedObject target)
        {
            InteractionContext ic = InteractionContext.InvokingAction(Session, false, RealTarget(target), Identifier, new[] { target });

            return(InteractionUtils.IsUsable(this, ic));
        }
Esempio n. 36
0
 public static bool Exists(this INakedObject nakedObject)
 {
     return(nakedObject != null && nakedObject.Object != null);
 }
Esempio n. 37
0
 public static IQueryable GetAsQueryable(this INakedObject objectRepresentingCollection)
 {
     return(objectRepresentingCollection.GetCollectionFacetFromSpec().AsQueryable(objectRepresentingCollection));
 }
        public static string IconName(INakedObject nakedObject)
        {
            string name = nakedObject.Spec.GetIconName(nakedObject);

            return(name.Contains(".") ? name : name + ".png");
        }
 public static IEnumerable <IActionSpec> GetTopLevelActions(this INakedObjectsFramework framework, INakedObject nakedObject)
 {
     if (nakedObject.Spec.IsQueryable)
     {
         var metamodel = framework.MetamodelManager.Metamodel;
         IObjectSpecImmutable elementSpecImmut = nakedObject.Spec.GetFacet <ITypeOfFacet>().GetValueSpec(nakedObject, metamodel);
         var elementSpec = framework.MetamodelManager.GetSpecification(elementSpecImmut) as IObjectSpec;
         Trace.Assert(elementSpec != null);
         return(elementSpec.GetCollectionContributedActions());
     }
     return(nakedObject.Spec.GetObjectActions().Where(a => a.IsVisible(nakedObject)));
 }
Esempio n. 40
0
 public INakedObject[] RealParameters(INakedObject target, INakedObject[] parameterSet)
 {
     return(parameterSet ?? (IsContributedMethod ? new[] { target } : new INakedObject[0]));
 }
Esempio n. 41
0
 public override bool IsVisible(INakedObject target)
 {
     return(base.IsVisible(RealTarget(target)));
 }
        public static string GetServiceId(this INakedObjectsFramework framework, string name)
        {
            INakedObject nakedObject = framework.GetAdaptedService(name);

            return(framework.GetObjectId(nakedObject));
        }
        public static string GetObjectTypeName(this INakedObjectsFramework framework, object model)
        {
            INakedObject nakedObject = framework.GetNakedObject(model);

            return(nakedObject.Spec.ShortName);
        }
Esempio n. 44
0
 public abstract string Invoke(INakedObject nakedObject, Exception exception);
Esempio n. 45
0
 /// <summary>
 ///     Safe (returns null if INakedObject is null) getter
 /// </summary>
 public static object GetDomainObject(this INakedObject inObject)
 {
     return(inObject == null ? null : inObject.Object);
 }
 public static bool IsViewModelEditView(this INakedObject target)
 {
     return(target.Spec.ContainsFacet <IViewModelFacet>() && target.Spec.GetFacet <IViewModelFacet>().IsEditView(target));
 }
Esempio n. 47
0
 /// <summary>
 ///     Safe (returns null if INakedObject is null) generic getter
 /// </summary>
 public static T GetDomainObject <T>(this INakedObject inObject)
 {
     return(inObject == null ? default(T) : (T)inObject.Object);
 }
 public static IEnumerable <IActionSpec> GetTopLevelActionsByReturnType(this INakedObjectsFramework framework, INakedObject nakedObject, IObjectSpec spec)
 {
     return(framework.GetTopLevelActions(nakedObject).
            Where(a => a.IsFinderMethod && a.IsVisible(nakedObject) && IsOfTypeOrCollectionOfType(a, spec)));
 }
Esempio n. 49
0
 public static IEnumerable <INakedObject> GetAsEnumerable(this INakedObject objectRepresentingCollection, INakedObjectManager manager)
 {
     return(objectRepresentingCollection.GetCollectionFacetFromSpec().AsEnumerable(objectRepresentingCollection, manager));
 }
 public static string GetObjectId(INakedObject nakedObject, CollectionMemento memento)
 {
     return(memento.Encode());
 }
Esempio n. 51
0
        public static ITypeOfFacet GetTypeOfFacetFromSpec(this INakedObject objectRepresentingCollection)
        {
            ITypeSpec collectionSpec = objectRepresentingCollection.Spec;

            return(collectionSpec.GetFacet <ITypeOfFacet>());
        }
        private static ElementDescriptor MenuItemAsElementDescriptor(this HtmlHelper html, IMenuItemImmutable item, INakedObject nakedObject, bool isEdit)
        {
            ElementDescriptor descriptor = null;

            if (item is IMenuActionImmutable)
            {
                descriptor = MenuActionAsElementDescriptor(html, item as IMenuActionImmutable, nakedObject, isEdit);
            }
            else if (item is IMenu)
            {
                descriptor = SubMenuAsElementDescriptor(html, item as IMenuImmutable, nakedObject, isEdit);
            }
            else if (item is CustomMenuItem)
            {
                descriptor = CustomMenuItemAsDescriptor(html, item as CustomMenuItem);
            }
            return(descriptor);
        }
Esempio n. 53
0
 public static IActionSpec GetActionLeafNode(this INakedObject nakedObject, string actionName)
 {
     return(nakedObject.GetActionLeafNodes().Single(x => x.Id == actionName));
 }
        private static ElementDescriptor MenuActionAsElementDescriptor(this HtmlHelper html, IMenuActionImmutable menuAction, INakedObject nakedObject, bool isEdit)
        {
            IActionSpecImmutable actionIm   = menuAction.Action;
            IActionSpec          actionSpec = html.Framework().MetamodelManager.GetActionSpec(actionIm);

            if (nakedObject == null)
            {
                IObjectSpecImmutable objectIm = actionIm.OwnerSpec; //This is the spec for the service

                if (!objectIm.Service)
                {
                    throw new Exception("Action is not on a known object or service");
                }
                //TODO: Add method to IServicesManager to get a service by its IObjectSpec (or IObjectSpecImmutable)
                ITypeSpec objectSpec = html.Framework().MetamodelManager.GetSpecification(objectIm);
                nakedObject = html.Framework().ServicesManager.GetServices().Single(s => s.Spec == objectSpec);
            }

            var actionContext = new ActionContext(false, nakedObject, actionSpec);

            RouteValueDictionary attributes;
            string tagType;
            string value;

            if (!actionContext.Action.IsVisible(actionContext.Target))
            {
                return(null);
            }
            IConsent consent = actionContext.Action.IsUsable(actionContext.Target);

            if (consent.IsVetoed)
            {
                tagType = html.GetVetoedAction(actionContext, consent, out value, out attributes);
            }
            else if (isEdit)
            {
                tagType = html.GetActionAsButton(actionContext, out value, out attributes);
            }
            else
            {
                tagType = html.GetActionAsForm(actionContext, html.Framework().GetObjectTypeName(actionContext.Target.Object), new { id = html.Framework().GetObjectId(actionContext.Target) }, out value, out attributes);
            }

            return(new ElementDescriptor {
                TagType = tagType,
                Value = value,
                Attributes = attributes
            });
        }
Esempio n. 55
0
 public string ValidateParms(INakedObject nakedObject, Tuple <string, INakedObject>[] parms)
 {
     return(null);
 }
        private static MvcHtmlString MenuAsHtml(this HtmlHelper html, IMenuImmutable menu, INakedObject nakedObject, bool isEdit)
        {
            var descriptors = new List <ElementDescriptor>();

            foreach (IMenuItemImmutable item in menu.MenuItems)
            {
                var descriptor = MenuItemAsElementDescriptor(html, item, nakedObject, isEdit);
                if (IsDuplicateAndIsVisibleActions(html, item, menu.MenuItems, nakedObject))
                {
                    //Test that both items are in fact visible
                    //The Id is set just to preseve backwards compatiblity
                    string id = menu.Id;
                    if (id.EndsWith("Actions"))
                    {
                        id = id.Split('-').First() + "-DuplicateAction";
                    }
                    descriptor = new ElementDescriptor {
                        TagType    = "div",
                        Value      = item.Name,
                        Attributes = new RouteValueDictionary(new {
                            @id    = id,
                            @class = IdHelper.ActionName,
                            title  = MvcUi.DuplicateAction
                        })
                    };
                }
                if (descriptor != null)   //Would be null for an invisible action
                {
                    descriptors.Add(descriptor);
                }
            }
            return(CommonHtmlHelper.BuildMenuContainer(descriptors,
                                                       IdHelper.MenuContainerName,
                                                       menu.Id,
                                                       menu.Name));
        }
 public static IEnumerable <IActionSpec> GetActions(this INakedObjectsFramework framework, INakedObject nakedObject)
 {
     return(nakedObject.Spec.GetObjectActions().Where(a => a.IsUsable(nakedObject).IsAllowed).
            Where(a => a.IsVisible(nakedObject)));
 }
Esempio n. 58
0
 public override string GetTitle(INakedObject nakedObject, INakedObjectManager nakedObjectManager)
 {
     return(nakedObject.Object.ToString());
 }
Esempio n. 59
0
 /// <summary>
 ///     Not yet implemented, so always returns <c>false</c>.
 /// </summary>
 public bool DoesNotMatch(INakedObject nakedObject)
 {
     return(false);
 }
 public static bool IsNotPersistent(this INakedObject nakedObject)
 {
     return((nakedObject.ResolveState.IsTransient() && nakedObject.Spec.Persistable == PersistableType.ProgramPersistable) ||
            nakedObject.Spec.Persistable == PersistableType.Transient);
 }