private static string GetMethodName(ChangeSetItem item, string suffix)
{
switch (item.Type)
{
case ChangeSetItemType.DataModification:
DataModificationItem dataModification = (DataModificationItem)item;
string operationName = null;
if (dataModification.DataModificationItemAction == DataModificationItemAction.Insert)
{
operationName = ConventionBasedChangeSetConstants.FilterMethodDataModificationInsert;
}
else if (dataModification.DataModificationItemAction == DataModificationItemAction.Update)
{
operationName = ConventionBasedChangeSetConstants.FilterMethodDataModificationUpdate;
}
else if (dataModification.DataModificationItemAction == DataModificationItemAction.Remove)
{
operationName = ConventionBasedChangeSetConstants.FilterMethodDataModificationDelete;
}
return operationName + suffix + dataModification.ResourceSetName;
default:
throw new InvalidOperationException(string.Format(
CultureInfo.InvariantCulture, Resources.InvalidChangeSetEntryType, item.Type));
}
}
/// <inheritdoc/>
public Task<bool> AuthorizeAsync(
SubmitContext context,
ChangeSetItem item,
CancellationToken cancellationToken)
{
Ensure.NotNull(context, "context");
bool result = true;
Type returnType = typeof(bool);
string methodName = GetAuthorizeMethodName(item);
MethodInfo method = this.targetType.GetQualifiedMethod(methodName);
if (method != null && method.IsFamily &&
method.ReturnType == returnType)
{
object target = null;
if (!method.IsStatic)
{
target = context.GetApiService<ApiBase>();
if (target == null ||
!this.targetType.IsInstanceOfType(target))
{
return Task.FromResult(result);
}
}
var parameters = method.GetParameters();
if (parameters.Length == 0)
{
result = (bool)method.Invoke(target, null);
}
}
return Task.FromResult(result);
}
private static string GetAuthorizeFailedMessage(ChangeSetItem item)
{
switch (item.Type)
{
case ChangeSetItemType.DataModification:
DataModificationItem dataModification = (DataModificationItem)item;
string message = null;
if (dataModification.DataModificationItemAction == DataModificationItemAction.Insert)
{
message = Resources.NoPermissionToInsertEntity;
}
else if (dataModification.DataModificationItemAction == DataModificationItemAction.Update)
{
message = Resources.NoPermissionToUpdateEntity;
}
else if (dataModification.DataModificationItemAction == DataModificationItemAction.Remove)
{
message = Resources.NoPermissionToDeleteEntity;
}
else
{
throw new NotSupportedException(Resources.DataModificationMustBeCUD);
}
return string.Format(CultureInfo.InvariantCulture, message, dataModification.ResourceSetName);
default:
throw new InvalidOperationException(string.Format(
CultureInfo.InvariantCulture,
Resources.InvalidChangeSetEntryType,
item.Type));
}
}
/// <inheritdoc/>
public Task OnChangeSetItemProcessedAsync(
SubmitContext context,
ChangeSetItem item,
CancellationToken cancellationToken)
{
return this.InvokeProcessorMethodAsync(
context, item, ConventionBasedChangeSetConstants.FilterMethodNamePostFilterSuffix);
}
/// <inheritdoc/>
public Task ValidateChangeSetItemAsync(
SubmitContext context,
ChangeSetItem item,
Collection<ChangeSetItemValidationResult> validationResults,
CancellationToken cancellationToken)
{
Ensure.NotNull(validationResults, "validationResults");
DataModificationItem dataModificationItem = item as DataModificationItem;
if (dataModificationItem != null)
{
object resource = dataModificationItem.Resource;
// TODO GitHubIssue#50 : should this PropertyDescriptorCollection be cached?
PropertyDescriptorCollection properties =
new DataAnnotations.AssociatedMetadataTypeTypeDescriptionProvider(resource.GetType())
.GetTypeDescriptor(resource).GetProperties();
DataAnnotations.ValidationContext validationContext = new DataAnnotations.ValidationContext(resource);
foreach (PropertyDescriptor property in properties)
{
validationContext.MemberName = property.Name;
IEnumerable<DataAnnotations.ValidationAttribute> validationAttributes =
property.Attributes.OfType<DataAnnotations.ValidationAttribute>();
foreach (DataAnnotations.ValidationAttribute validationAttribute in validationAttributes)
{
object value = property.GetValue(resource);
DataAnnotations.ValidationResult validationResult =
validationAttribute.GetValidationResult(value, validationContext);
if (validationResult != DataAnnotations.ValidationResult.Success)
{
validationResults.Add(new ChangeSetItemValidationResult()
{
Id = validationAttribute.GetType().FullName,
Message = validationResult.ErrorMessage,
Severity = EventLevel.Error,
Target = resource,
PropertyName = property.Name
});
}
}
}
}
return Task.WhenAll();
}
public Task OnChangeSetItemProcessedAsync(SubmitContext context, ChangeSetItem item, CancellationToken cancellationToken)
{
var dataModificationItem = item as DataModificationItem;
if (dataModificationItem != null)
{
object myEntity = dataModificationItem.Resource;
string entitySetName = dataModificationItem.ResourceSetName;
DataModificationItemAction operation = dataModificationItem.DataModificationItemAction;
// In case of insert, the request URL has no key, and request body may not have key neither as the key may be generated by database
var keyAttrbiutes = new Dictionary<string, object>();
var keyConvention = new Dictionary<string, object>();
var entityTypeName = myEntity.GetType().Name;
PropertyInfo[] properties = myEntity.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
var attribute = Attribute.GetCustomAttribute(property, typeof(KeyAttribute))
as KeyAttribute;
var propName = property.Name;
// This is getting key with Key attribute defined
if (attribute != null) // This property has a KeyAttribute
{
// Do something, to read from the property:
object val = property.GetValue(myEntity);
keyAttrbiutes.Add(propName, val);
}
// This is getting key based on convention
else if(propName.ToLower().Equals("id") || propName.ToLower().Equals(entityTypeName.ToLower()+"id"))
{
object val = property.GetValue(myEntity);
keyConvention.Add(propName, val);
}
}
if (keyAttrbiutes.Count > 0)
{
// Use property with key attribute as keys
}
else if(keyConvention.Count > 0)
{
// Key is defined based on convention
}
}
return Inner.OnChangeSetItemProcessedAsync(context, item, cancellationToken);
}
public Task OnChangeSetItemProcessingAsync(SubmitContext context, ChangeSetItem item, CancellationToken cancellationToken)
{
return Inner.OnChangeSetItemProcessingAsync(context, item, cancellationToken);
}
private static object[] GetParameters(ChangeSetItem item)
{
switch (item.Type)
{
case ChangeSetItemType.DataModification:
DataModificationItem dataModification = (DataModificationItem)item;
return new object[] { dataModification.Resource };
default:
throw new InvalidOperationException(string.Format(
CultureInfo.InvariantCulture, Resources.InvalidChangeSetEntryType, item.Type));
}
}
private Task InvokeProcessorMethodAsync(
SubmitContext context,
ChangeSetItem item,
string methodNameSuffix)
{
string methodName = GetMethodName(item, methodNameSuffix);
object[] parameters = GetParameters(item);
MethodInfo method = this.targetType.GetQualifiedMethod(methodName);
if (method != null &&
(method.ReturnType == typeof(void) ||
typeof(Task).IsAssignableFrom(method.ReturnType)))
{
object target = null;
if (!method.IsStatic)
{
target = context.GetApiService<ApiBase>();
if (target == null ||
!this.targetType.IsInstanceOfType(target))
{
return Task.WhenAll();
}
}
ParameterInfo[] methodParameters = method.GetParameters();
if (ParametersMatch(methodParameters, parameters))
{
object result = method.Invoke(target, parameters);
Task resultTask = result as Task;
if (resultTask != null)
{
return resultTask;
}
}
}
return Task.WhenAll();
}
