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); }
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); }
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); }
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; }
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); } }
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); }
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)); }
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>()); }
public string Validate(INakedObject nakedObject) { return(null); }
public override void Invoke(INakedObject nakedObject, ISession session, ILifecycleManager lifecycleManager, IMetamodelManager metamodelManager) { InvokeUtils.Invoke(method, nakedObject); }
public static IActionSpec[] GetActionLeafNodes(this INakedObject nakedObject) { return(nakedObject.Spec.GetActionLeafNodes()); }
public override IConsent IsUsable(INakedObject target) { InteractionContext ic = InteractionContext.InvokingAction(Session, false, RealTarget(target), Identifier, new[] { target }); return(InteractionUtils.IsUsable(this, ic)); }
public static bool Exists(this INakedObject nakedObject) { return(nakedObject != null && nakedObject.Object != null); }
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))); }
public INakedObject[] RealParameters(INakedObject target, INakedObject[] parameterSet) { return(parameterSet ?? (IsContributedMethod ? new[] { target } : new INakedObject[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); }
public abstract string Invoke(INakedObject nakedObject, Exception exception);
/// <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)); }
/// <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))); }
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()); }
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); }
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 }); }
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))); }
public override string GetTitle(INakedObject nakedObject, INakedObjectManager nakedObjectManager) { return(nakedObject.Object.ToString()); }
/// <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); }