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());
}
public ObjectContext(NakedObject target)
{
Target = target;
}
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));
}
