private static ParameterContext[] GetContextParms(ActionWrapper action, NakedObject target) { NakedObjectActionParameter[] parms = action.GetParameters(target); return(parms.Select(p => new ParameterContext { Action = action, Parameter = p }).ToArray()); }
public static void ClearValue(OneToOneAssociation property, NakedObject target) { object valueHolder = property.get(target).getObject(); MethodInfo m = valueHolder.GetType().GetMethod("clear"); m.Invoke(valueHolder, new object[] {}); }
public static void SetValue <T>(OneToOneAssociation property, NakedObject target, Naked proposed) { object valueHolder = property.get(target).getObject(); MethodInfo m = valueHolder.GetType().GetMethod("setValue", new[] { typeof(T) }); m.Invoke(valueHolder, new[] { proposed.getObject() }); }
private static void ValidateConcurrency(NakedObject nakedObject, string digest) { if (!string.IsNullOrEmpty(digest) && new VersionFacade(nakedObject.getVersion()).IsDifferent(digest)) { throw new PreconditionFailedNOSException(); } }
private PropertyContext GetProperty(NakedObject nakedObject, string propertyName, bool onlyVisible = true) { if (string.IsNullOrEmpty(propertyName.Trim())) { throw new BadRequestNOSException(); } string nof2Id = propertyName.ToLower(); IEnumerable <NakedObjectField> fields = nakedObject.getSpecification().getFields(); if (onlyVisible) { fields = fields.Where(p => !p.isHidden() && p.isVisible(nakedObject).isAllowed()); } NakedObjectField property = fields.SingleOrDefault(p => p.getId() == nof2Id); if (property == null) { throw new PropertyResourceNotFoundNOSException(propertyName); } if (!property.isCollection()) { property.get(nakedObject); // get value so any errors happen inside error mapping code } return(new PropertyContext { Target = nakedObject, Property = property }); }
public ITestObject AssertIsType(Type expected) { Type actualType = NakedObject.GetDomainObject().GetType(); actualType = TypeUtils.IsProxy(actualType) ? actualType.BaseType : actualType; Assert.IsTrue(actualType == expected, "Expected type " + expected + " but got " + actualType); return(this); }
private static Consent IsCurrentlyImmutable(NakedObject target) { if (target.persistable() == Persistable.IMMUTABLE) { return(new Veto("Is immutable")); } return(new Allow()); }
private PropertyContext SetupPropertyContext(NakedObject nakedObject, string propertyName, object toAdd) { PropertyContext context = GetProperty(nakedObject, propertyName); context.ProposedValue = toAdd; context.ProposedNakedObject = [email protected]().getAdapterFor(toAdd); return(context); }
public object GetServiceByServiceName(string serviceName) { NakedObject service = GetServiceByServiceNameInternal(serviceName); if (service == null) { throw new ServiceResourceNotFoundNOSException(serviceName); } return(service.getObject()); }
private void SetAssociation(OneToOneAssociation property, NakedObject target, Naked proposed) { if (proposed is NakedObject) { property.setAssociation(target, (NakedObject)proposed); } else { MethodInfo m = GetType().GetMethod("SetValue").MakeGenericMethod(proposed.getObject().GetType()); m.Invoke(null, new object[] { property, target, proposed }); } }
public ActionContextFacade GetObjectAction(IOidTranslation objectId, string actionName) { return(MapErrors(() => { if (string.IsNullOrEmpty(actionName.Trim())) { throw new BadRequestNOSException(); } NakedObject nakedObject = GetObjectAsNakedObject(objectId); return GetAction(actionName, nakedObject).ToActionContextFacade(this); })); }
private static Consent IsAssociationValid(OneToOneAssociation property, NakedObject target, Naked proposed, bool allowDisabled = false) { if (allowDisabled && property.isAvailable(target).isVetoed()) { return(new Allow()); } if (proposed is NakedObject) { return(property.isAssociationValid(target, (NakedObject)proposed)); } return(property.isValueValid(target, (NakedValue)proposed)); }
private static bool ClearAssociation(OneToOneAssociation property, NakedObject target) { Naked existingValue = property.get(target); if (existingValue != null) { if (existingValue is NakedObject) { property.clearAssociation(target, (NakedObject)existingValue); } else { ClearValue(property, target); } return(true); } return(false); }
private ObjectContextFacade SetObject(NakedObject nakedObject, ArgumentsContextFacade arguments) { if (nakedObject.getSpecification().getFields().Where(f => !f.isCollection()).Any(p => !arguments.Values.Keys.Select(s => s.ToLower()).Contains(p.getId()))) { throw new BadRequestNOSException("Malformed arguments"); } PropertyContext[] pc = arguments.Values.Select(kvp => CanSetProperty(nakedObject, kvp.Key, arguments.ValidateOnly, kvp.Value)).ToArray(); var objectContext = new ObjectContext(pc.First().Target) { VisibleProperties = pc }; // if we fail we need to display all - if OK only those that are visible PropertyContext[] propertiesToDisplay = objectContext.VisibleProperties; if (pc.All(c => string.IsNullOrEmpty(c.Reason))) { if (nakedObject.getResolveState().isTransient()) { if (nakedObject.getSpecification().persistable() == Persistable.USER_PERSISTABLE) { [email protected]().makePersistent(nakedObject); } else { [email protected]().objectChanged(nakedObject); } } propertiesToDisplay = nakedObject.getSpecification().getFields(). Where(p => !p.isHidden() && p.isVisible(nakedObject).isAllowed()). Select(p => new PropertyContext { Target = nakedObject, Property = p }).ToArray(); } ObjectContext oc = GetObjectContext(objectContext.Target); oc.Mutated = false; oc.Reason = objectContext.Reason; oc.VisibleProperties = propertiesToDisplay; return(oc.ToObjectContextFacade(this)); }
private static ActionContext GetAction(string actionName, NakedObject nakedObject) { if (string.IsNullOrWhiteSpace(actionName.Trim())) { throw new BadRequestNOSException(); } ActionWrapper action = nakedObject.getSpecification().GetActionLeafNodes(). Where(p => p.isVisible(nakedObject).isAllowed()).SingleOrDefault(p => p.getId() == actionName); if (action == null) { throw new ActionResourceNotFoundNOSException(actionName); } return(new ActionContext { Target = nakedObject, Action = action, VisibleParameters = GetContextParms(action, nakedObject) }); }
public object GetDomainObjectByOid(string oid) { long idAsLong; if (!long.TryParse(oid, out idAsLong)) { // check if it's a service NakedObject service = GetServiceByServiceNameInternal(oid); if (service == null) { throw new BadRequestNOSException(); } return(service.getObject()); } var serialOid = new SerialOid(idAsLong); NakedObject adapter = [email protected]().getAdapterFor(serialOid); return(adapter.getObject()); }
private PropertyContext CanSetProperty(NakedObject nakedObject, string propertyName, bool validateOnly, object toPut = null) { PropertyContext context = GetProperty(nakedObject, propertyName, false); context.ProposedValue = toPut; var property = (OneToOneAssociation)context.Property; if (ConsentHandler(IsCurrentlyImmutable(context.Target), context, Cause.Immutable)) { if (toPut == null) { if (property.isMandatory()) { context.Reason = "Mandatory"; context.ErrorCause = Cause.Other; } else if (!validateOnly) { ClearAssociation(property, context.Target); } } else { if (ConsentHandler(CanSetPropertyValue(context), context, Cause.Other)) { if (ConsentHandler(IsAssociationValid(property, context.Target, context.ProposedNakedObject, true), context, Cause.Other)) { if (!validateOnly) { SetAssociation(property, context.Target, context.ProposedNakedObject); } } } } } return(context); }
private ObjectContextFacade ChangeObject(NakedObject nakedObject, ArgumentsContextFacade arguments) { ValidateConcurrency(nakedObject, arguments.Digest); PropertyContext[] pc; try { pc = arguments.Values.Select(kvp => CanChangeProperty(nakedObject, kvp.Key, arguments.ValidateOnly, kvp.Value)).ToArray(); } catch (PropertyResourceNotFoundNOSException e) { // no matching property for argument - consider this a syntax error throw new BadRequestNOSException(e.Message); } var objectContext = new ObjectContext(pc.First().Target) { VisibleProperties = pc }; // if we fail we need to display passed in properties - if OK all visible PropertyContext[] propertiesToDisplay = objectContext.VisibleProperties; if (pc.All(c => string.IsNullOrEmpty(c.Reason))) { propertiesToDisplay = nakedObject.getSpecification().getFields(). Where(p => !p.isHidden() && p.isVisible(nakedObject).isAllowed()). Select(p => new PropertyContext { Target = nakedObject, Property = p }).ToArray(); } ObjectContext oc = GetObjectContext(objectContext.Target); oc.Mutated = true; oc.Reason = objectContext.Reason; oc.VisibleProperties = propertiesToDisplay; return(oc.ToObjectContextFacade(this)); }
private PropertyContext CanChangeProperty(NakedObject nakedObject, string propertyName, bool validateOnly, object toPut = null) { PropertyContext context = GetProperty(nakedObject, propertyName); context.ProposedValue = toPut; var property = (OneToOneAssociation)context.Property; if (ConsentHandler(IsCurrentlyImmutable(context.Target), context, Cause.Immutable)) { if (ConsentHandler(property.isAvailable(context.Target), context, Cause.Disabled)) { if (toPut == null) { if (!validateOnly) { context.Mutated = ClearAssociation(property, context.Target); } } else { if (ConsentHandler(CanSetPropertyValue(context), context, Cause.Other)) { if (ConsentHandler(IsAssociationValid(property, context.Target, context.ProposedNakedObject), context, Cause.Other)) { if (!validateOnly) { SetAssociation(property, context.Target, context.ProposedNakedObject); context.Mutated = true; } } } } } } context.Mutated = true; return(context); }
public object GetDomainObjectByOid(IOidTranslation objectId) { Type type = ValidateObjectId(objectId); string[] keys = GetKeys(objectId.InstanceId, type); NakedObjectSpecification spec = [email protected]().loadSpecification(type.FullName); NakedObject pattern = [email protected]().createTransientInstance(spec); PropertyInfo p = pattern.getObject().GetType().GetProperty("Id"); ((WholeNumber)p.GetValue(pattern.getObject(), null)).setValue(int.Parse(keys.First())); var criteria = new TitleCriteria(spec, pattern.titleString(), false); TypedNakedCollection results = [email protected]().findInstances(criteria); if (results.size() == 0) { throw new ObjectResourceNotFoundNOSException(objectId.ToString()); } return(results.elementAt(0).getObject()); }
private ObjectContext GetServiceInternal(IOidTranslation serviceName) { NakedObject nakedObject = GetServiceAsNakedObject(serviceName); return(GetObjectContext(nakedObject)); }
public ObjectContext(NakedObject target) { Target = target; }
public override int GetHashCode() { return(NakedObject.GetHashCode()); }
public object GetDomainObject() { return(NakedObject.GetDomainObject()); }
public static ActionWrapper GetActionLeafNode(this NakedObject nakedObject, string actionName) { return(nakedObject.GetActionLeafNodes().Single(x => x.getId() == actionName)); }
public override string ToString() { return(NakedObject == null ? "" : NakedObject.ToString()); }
public static ActionWrapper[] GetActionLeafNodes(this NakedObject nakedObject) { return(nakedObject.getSpecification().GetActionLeafNodes()); }
private ActionContext GetInvokeActionOnObject(IOidTranslation objectId, string actionName) { NakedObject nakedObject = GetObjectAsNakedObject(objectId); return(GetAction(actionName, nakedObject)); }
private ActionContext GetInvokeActionOnService(IOidTranslation serviceName, string actionName) { NakedObject nakedObject = GetServiceAsNakedObject(serviceName); return(GetAction(actionName, nakedObject)); }
private PropertyContextFacade ChangeProperty(NakedObject nakedObject, string propertyName, ArgumentContextFacade argument) { ValidateConcurrency(nakedObject, argument.Digest); return(CanChangeProperty(nakedObject, propertyName, argument.ValidateOnly, argument.Value).ToPropertyContextFacade(this)); }