public object GetModelAttribute(int entityID, ModelAttributes att)
{
if (att == ModelAttributes.Color)
{
return ((ColorDataItem)Entities[entityID]).GetColorAttribute();
}
else return null;
}
/// <summary>
/// Creates a new <see cref="DefaultMetadataDetails"/>.
/// </summary>
/// <param name="key">The <see cref="ModelMetadataIdentity"/>.</param>
/// <param name="attributes">The set of model attributes.</param>
public DefaultMetadataDetails(ModelMetadataIdentity key, ModelAttributes attributes)
{
if (attributes == null)
{
throw new ArgumentNullException(nameof(attributes));
}
Key = key;
ModelAttributes = attributes;
}
public void CreateDisplayMetadata_NullContainerType_DoesNotSetDisplayName()
{
DisplayMetadataProvider provider = new();
DisplayMetadataProviderContext context = new(
ModelMetadataIdentity.ForType(typeof(RoleView)),
ModelAttributes.GetAttributesForType(typeof(RoleView)));
provider.CreateDisplayMetadata(context);
Assert.Null(context.DisplayMetadata.DisplayName);
}
public void CreateModelMetadata_NullContainerType_DoesNotSetDisplayName()
{
DefaultMetadataDetails metaDetails = new DefaultMetadataDetails(
new ModelMetadataIdentity(), ModelAttributes.GetAttributesForType(typeof(RoleView)));
ICompositeMetadataDetailsProvider details = Substitute.For <ICompositeMetadataDetailsProvider>();
DisplayNameMetadataProviderProxy provider = new DisplayNameMetadataProviderProxy(details);
String actual = provider.BaseCreateModelMetadata(metaDetails).DisplayName;
Assert.Null(actual);
}
private ModelMetadata GetRequiredMetadata()
{
var details = new DefaultMetadataDetails(ModelMetadataIdentity.ForType(typeof(string)),
ModelAttributes.GetAttributesForType(typeof(string)))
{
ValidationMetadata = new ValidationMetadata {
IsRequired = true
}
};
return(new DefaultModelMetadata(new EmptyModelMetadataProvider(), new DefaultCompositeMetadataDetailsProvider(new IMetadataDetailsProvider[0]), details));
}
private IEnumerable <ApiParameterDescription> GetParametersDescription(MethodInfo methodInfo, string route)
{
foreach (var parameter in methodInfo.GetParameters())
{
var requestBodyTypeAttribute =
parameter.GetCustomAttribute(typeof(RequestBodyTypeAttribute)) as RequestBodyTypeAttribute;
if ((parameter.ParameterType == typeof(HttpRequestMessage) ||
parameter.ParameterType == typeof(HttpRequest)) &&
requestBodyTypeAttribute == null)
{
continue;
}
if (IgnoreParameter(parameter))
{
continue;
}
var hasHttpTriggerAttribute = parameter.GetCustomAttributes()
.Any(attr => attr is HttpTriggerAttribute);
var hasFromUriAttribute = false;
var type = hasHttpTriggerAttribute && requestBodyTypeAttribute != null
? requestBodyTypeAttribute.Type
: parameter.ParameterType;
var regex = GetRoutePathParamRegex(parameter.Name);
var match = regex.Match(route);
var bindingSource = match.Success ? BindingSource.Path
: hasFromUriAttribute ? BindingSource.Query
: BindingSource.Body;
var optional = bindingSource == BindingSource.Query || match.Value.Contains("?");
yield return(new ApiParameterDescription
{
Name = parameter.Name,
Type = type,
Source = bindingSource,
RouteInfo = new ApiParameterRouteInfo
{
IsOptional = optional
},
ModelMetadata = new DefaultModelMetadata(_modelMetadataProvider, _compositeMetadataDetailsProvider,
new DefaultMetadataDetails(
ModelMetadataIdentity.ForType(type),
ModelAttributes.GetAttributesForType(type)))
});
}
}
public void CreateDisplayMetadata_SetsDisplayName()
{
PropertyInfo property = typeof(RoleView).GetProperty(nameof(RoleView.Title)) !;
DisplayMetadataProviderContext context = new(
ModelMetadataIdentity.ForProperty(property, typeof(String), typeof(RoleView)),
ModelAttributes.GetAttributesForType(typeof(RoleView)));
new DisplayMetadataProvider().CreateDisplayMetadata(context);
String expected = Resource.ForProperty(typeof(RoleView), nameof(RoleView.Title));
String actual = context.DisplayMetadata.DisplayName();
Assert.Equal(expected, actual);
}
public void CreateDisplayMetadata_SetsDisplayName()
{
DisplayMetadataProvider provider = new DisplayMetadataProvider();
DisplayMetadataProviderContext context = new DisplayMetadataProviderContext(
ModelMetadataIdentity.ForProperty(typeof(String), "Title", typeof(RoleView)),
ModelAttributes.GetAttributesForType(typeof(RoleView)));
provider.CreateDisplayMetadata(context);
String expected = Resource.ForProperty(typeof(RoleView), "Title");
String actual = context.DisplayMetadata.DisplayName();
Assert.Equal(expected, actual);
}
private static DefaultMetadataDetails CreateMetadataDetails(ActionExecutionModel model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
var modelMetadataIdentity = ModelMetadataIdentity.ForType(model.GetType());
var modelAttributes = ModelAttributes.GetAttributesForType(model.GetType());
var modelMetadataDetails = new DefaultMetadataDetails(modelMetadataIdentity, modelAttributes);
return(modelMetadataDetails);
}
public void GetAttributesForParameter_NoAttributes()
{
// Arrange & Act
var attributes = ModelAttributes.GetAttributesForParameter(
typeof(MethodWithParamAttributesType)
.GetMethod(nameof(MethodWithParamAttributesType.Method))
.GetParameters()[0]);
// Assert
// Not exactly "no attributes" due to SerializableAttribute on object.
Assert.IsType <SerializableAttribute>(Assert.Single(attributes.Attributes));
Assert.Empty(attributes.ParameterAttributes);
Assert.Null(attributes.PropertyAttributes);
Assert.Equal(attributes.Attributes, attributes.TypeAttributes);
}
public void CreateValidationMetadata_SetValidationPropertyName_CamelCaseWithDefaultNamingPolicy()
{
var metadataProvider = new SystemTextJsonValidationMetadataProvider();
var propertyName = nameof(SampleTestClass.NoAttributesProperty);
var key = ModelMetadataIdentity.ForProperty(typeof(SampleTestClass).GetProperty(propertyName), typeof(int), typeof(SampleTestClass));
var modelAttributes = new ModelAttributes(Array.Empty <object>(), Array.Empty <object>(), Array.Empty <object>());
var context = new ValidationMetadataProviderContext(key, modelAttributes);
// Act
metadataProvider.CreateValidationMetadata(context);
// Assert
Assert.NotNull(context.ValidationMetadata.ValidationModelName);
Assert.Equal(JsonNamingPolicy.CamelCase.ConvertName(propertyName), context.ValidationMetadata.ValidationModelName);
}
public void CreateValidationMetadata_SetValidationPropertyName_WithJsonPropertyNameAttribute()
{
var metadataProvider = new SystemTextJsonValidationMetadataProvider();
var propertyName = "sample-data";
var key = ModelMetadataIdentity.ForProperty(typeof(SampleTestClass).GetProperty(nameof(SampleTestClass.NoAttributesProperty)), typeof(int), typeof(SampleTestClass));
var modelAttributes = new ModelAttributes(Array.Empty <object>(), new[] { new JsonPropertyNameAttribute(propertyName) }, Array.Empty <object>());
var context = new ValidationMetadataProviderContext(key, modelAttributes);
// Act
metadataProvider.CreateValidationMetadata(context);
// Assert
Assert.NotNull(context.ValidationMetadata.ValidationModelName);
Assert.Equal(propertyName, context.ValidationMetadata.ValidationModelName);
}
public void GetAttributesForBasePropertyFromDerivedModel_IncludesMetadataAttributes()
{
// Arrange
var modelType = typeof(DerivedViewModel);
var property = modelType.GetRuntimeProperties().FirstOrDefault(p => p.Name == nameof(BaseModel.BaseProperty));
// Act
var attributes = ModelAttributes.GetAttributesForProperty(modelType, property);
// Assert
Assert.Single(attributes.Attributes.OfType <RequiredAttribute>());
Assert.Single(attributes.Attributes.OfType <StringLengthAttribute>());
Assert.Single(attributes.PropertyAttributes.OfType <RequiredAttribute>());
Assert.Single(attributes.PropertyAttributes.OfType <StringLengthAttribute>());
}
public void CreateValidationMetadata_SetValidationPropertyName_WithJsonNamingPolicy(NamingStrategy namingStrategy)
{
var metadataProvider = new NewtonsoftJsonValidationMetadataProvider(namingStrategy);
var propertyName = nameof(SampleTestClass.NoAttributesProperty);
var key = ModelMetadataIdentity.ForProperty(typeof(SampleTestClass).GetProperty(propertyName), typeof(int), typeof(SampleTestClass));
var modelAttributes = new ModelAttributes(Array.Empty <object>(), Array.Empty <object>(), Array.Empty <object>());
var context = new ValidationMetadataProviderContext(key, modelAttributes);
// Act
metadataProvider.CreateValidationMetadata(context);
// Assert
Assert.NotNull(context.ValidationMetadata.ValidationModelName);
Assert.Equal(namingStrategy.GetPropertyName(propertyName, false), context.ValidationMetadata.ValidationModelName);
}
public void CreateValidationMetadata_DoesNotSetHasValidators_IfProviderIsConfigured()
{
// Arrange
var validationProviders = new IModelValidatorProvider[0];
var metadataProvider = new HasValidatorsValidationMetadataProvider(validationProviders);
var key = ModelMetadataIdentity.ForType(typeof(object));
var modelAttributes = new ModelAttributes(new object[0], new object[0], new object[0]);
var context = new ValidationMetadataProviderContext(key, modelAttributes);
// Act
metadataProvider.CreateValidationMetadata(context);
// Assert
Assert.Null(context.ValidationMetadata.HasValidators);
}
public void GetFromServiceAttributeFromBase_IncludesMetadataAttributes()
{
// Arrange
var modelType = typeof(DerivedViewModel);
var property = modelType.GetRuntimeProperties().FirstOrDefault(p => p.Name == nameof(BaseModel.RouteValue));
// Act
var attributes = ModelAttributes.GetAttributesForProperty(modelType, property);
// Assert
Assert.Single(attributes.Attributes.OfType <RequiredAttribute>());
Assert.Single(attributes.Attributes.OfType <FromRouteAttribute>());
Assert.Single(attributes.PropertyAttributes.OfType <RequiredAttribute>());
Assert.Single(attributes.PropertyAttributes.OfType <FromRouteAttribute>());
}
/// <summary>
/// Creates a new <see cref="DisplayMetadataProviderContext"/>.
/// </summary>
/// <param name="key">The <see cref="ModelMetadataIdentity"/> for the <see cref="ModelMetadata"/>.</param>
/// <param name="attributes">The attributes for the <see cref="ModelMetadata"/>.</param>
public DisplayMetadataProviderContext(
ModelMetadataIdentity key,
ModelAttributes attributes)
{
if (attributes == null)
{
throw new ArgumentNullException(nameof(attributes));
}
Key = key;
Attributes = attributes.Attributes;
PropertyAttributes = attributes.PropertyAttributes;
TypeAttributes = attributes.TypeAttributes;
DisplayMetadata = new DisplayMetadata();
}
/// <summary>
/// Creates a new <see cref="ValidationMetadataProviderContext"/>.
/// </summary>
/// <param name="key">The <see cref="ModelMetadataIdentity"/> for the <see cref="ModelMetadata"/>.</param>
/// <param name="attributes">The attributes for the <see cref="ModelMetadata"/>.</param>
public ValidationMetadataProviderContext(
ModelMetadataIdentity key,
ModelAttributes attributes)
{
if (attributes == null)
{
throw new ArgumentNullException(nameof(attributes));
}
Key = key;
Attributes = attributes.Attributes;
PropertyAttributes = attributes.PropertyAttributes;
TypeAttributes = attributes.TypeAttributes;
ValidationMetadata = new ValidationMetadata();
}
public static IEnumerable <KeyValuePair <Type, ModelMetadata> > CreateMetadataForTypes(params Type[] types)
{
var provider = new EmptyModelMetadataProvider();
var detailsProvider = new DefaultCompositeMetadataDetailsProvider(
Enumerable.Empty <IMetadataDetailsProvider>());
foreach (var type in types)
{
var key = ModelMetadataIdentity.ForType(type);
var cache = new DefaultMetadataDetails(key, ModelAttributes.GetAttributesForType(type));
var metadata = new DefaultModelMetadata(provider, detailsProvider, cache);
Xunit.Assert.Equal(type, metadata.ModelType);
Xunit.Assert.Null(metadata.PropertyName);
Xunit.Assert.Null(metadata.ContainerType);
yield return(KeyValuePair.Create <Type, ModelMetadata>(type, metadata));
}
}
public void GetAttributesForParameter_IncludesTypeAttributes()
{
// Arrange
var parameters = typeof(MethodWithParamAttributesType)
.GetMethod(nameof(MethodWithParamAttributesType.Method))
.GetParameters();
// Act
var attributes = ModelAttributes.GetAttributesForParameter(parameters[2]);
// Assert
Assert.Collection(attributes.Attributes,
attribute => Assert.IsType <BindRequiredAttribute>(attribute),
attribute => Assert.IsType <ClassValidator>(attribute));
Assert.IsType <BindRequiredAttribute>(Assert.Single(attributes.ParameterAttributes));
Assert.Null(attributes.PropertyAttributes);
Assert.IsType <ClassValidator>(Assert.Single(attributes.TypeAttributes));
}
public void GetBinderReturnsNullForUnsupportedTypeTest()
{
var context = Substitute.For <ModelBinderProviderContext>();
var provider = Substitute.For <IModelMetadataProvider>();
var detailsProvider = Substitute.For <ICompositeMetadataDetailsProvider>();
var key = ModelMetadataIdentity.ForType(typeof(string));
IEnumerable <object> typeAttributes = new List <object>();
var attributes = new ModelAttributes(typeAttributes);
var details = new DefaultMetadataDetails(key, attributes);
var metadata = new DefaultModelMetadata(provider, detailsProvider, details);
context.Metadata.Returns(metadata);
var sut = new ProfileFilterModelBinderProvider();
var actual = sut.GetBinder(context);
actual.Should().BeNull();
}
public void CreateValidationMetadata_DoesNotSetHasValidators_IfNonMetadataBasedProviderExists()
{
// Arrange
var validationProviders = new IModelValidatorProvider[]
{
new DefaultModelValidatorProvider(),
Mock.Of <IModelValidatorProvider>(),
};
var metadataProvider = new HasValidatorsValidationMetadataProvider(validationProviders);
var key = ModelMetadataIdentity.ForType(typeof(object));
var modelAttributes = new ModelAttributes(new object[0], new object[0], new object[0]);
var context = new ValidationMetadataProviderContext(key, modelAttributes);
// Act
metadataProvider.CreateValidationMetadata(context);
// Assert
Assert.Null(context.ValidationMetadata.HasValidators);
}
private DefaultMetadataDetails CreateSinglePropertyDetails(ModelMetadataIdentity propertyKey, PropertyInfo property)
{
var containerType = propertyKey.ContainerType;
var attributes = ModelAttributes.GetAttributesForProperty(containerType, property, propertyKey.ModelType);
var propertyEntry = new DefaultMetadataDetails(propertyKey, attributes);
if (property.CanRead && property.GetMethod?.IsPublic == true)
{
propertyEntry.PropertyGetter = property.MakeFastGetter <object, object>();
}
if (property.CanWrite && property.SetMethod?.IsPublic == true && !containerType.IsValueType)
{
propertyEntry.PropertySetter = property.MakeFastSetter <object, object>();
}
return(propertyEntry);
}
public void CreateValidationMetadata_SetsHasValidatorsToFalse_IfNoProviderReturnsTrue()
{
// Arrange
var provider = Mock.Of <IMetadataBasedModelValidatorProvider>(p => p.HasValidators(typeof(object), It.IsAny <IList <object> >()) == false);
var validationProviders = new IModelValidatorProvider[]
{
new DefaultModelValidatorProvider(),
provider,
};
var metadataProvider = new HasValidatorsValidationMetadataProvider(validationProviders);
var key = ModelMetadataIdentity.ForType(typeof(object));
var modelAttributes = new ModelAttributes(new object[0], new object[0], new object[0]);
var context = new ValidationMetadataProviderContext(key, modelAttributes);
// Act
metadataProvider.CreateValidationMetadata(context);
// Assert
Assert.False(context.ValidationMetadata.HasValidators);
}
public void GetAttributesForProperty_WithModelType_IncludesTypeAttributes()
{
// Arrange
var property = typeof(MergedAttributes)
.GetProperty(nameof(MergedAttributes.BaseModel));
// Act
var attributes = ModelAttributes.GetAttributesForProperty(typeof(MergedAttributes), property, typeof(DerivedModelWithAttributes));
// Assert
Assert.Collection(
attributes.Attributes,
attribute => Assert.IsType <BindRequiredAttribute>(attribute),
attribute => Assert.IsType <ModelBinderAttribute>(attribute),
attribute => Assert.IsType <ClassValidator>(attribute));
Assert.IsType <BindRequiredAttribute>(Assert.Single(attributes.PropertyAttributes));
Assert.Null(attributes.ParameterAttributes);
Assert.Collection(
attributes.TypeAttributes,
attribute => Assert.IsType <ModelBinderAttribute>(attribute),
attribute => Assert.IsType <ClassValidator>(attribute));
}
public void GetAttributesForProperty_MergedAttributes()
{
// Arrange
var property = typeof(MergedAttributes).GetRuntimeProperty(nameof(MergedAttributes.Property));
// Act
var attributes = ModelAttributes.GetAttributesForProperty(typeof(MergedAttributes), property);
// Assert
Assert.Equal(3, attributes.Attributes.Count);
Assert.IsType <RequiredAttribute>(attributes.Attributes[0]);
Assert.IsType <RangeAttribute>(attributes.Attributes[1]);
Assert.IsType <ClassValidator>(attributes.Attributes[2]);
Assert.Equal(2, attributes.PropertyAttributes.Count);
Assert.IsType <RequiredAttribute>(attributes.PropertyAttributes[0]);
Assert.IsType <RangeAttribute>(attributes.PropertyAttributes[1]);
var attribute = Assert.Single(attributes.TypeAttributes);
Assert.IsType <ClassValidator>(attribute);
}
/// <summary>
/// Creates the <see cref="DefaultMetadataDetails"/> entries for the properties of a model
/// <see cref="Type"/>.
/// </summary>
/// <param name="key">
/// The <see cref="ModelMetadataIdentity"/> identifying the model <see cref="Type"/>.
/// </param>
/// <returns>A details object for each property of the model <see cref="Type"/>.</returns>
/// <remarks>
/// The results of this method will be cached and used to satisfy calls to
/// <see cref="GetMetadataForProperties(Type)"/>. Override this method to provide a different
/// set of property data.
/// </remarks>
protected virtual DefaultMetadataDetails[] CreatePropertyDetails(ModelMetadataIdentity key)
{
var propertyHelpers = PropertyHelper.GetVisibleProperties(key.ModelType);
var propertyEntries = new List <DefaultMetadataDetails>(propertyHelpers.Length);
for (var i = 0; i < propertyHelpers.Length; i++)
{
var propertyHelper = propertyHelpers[i];
var propertyKey = ModelMetadataIdentity.ForProperty(
propertyHelper.Property.PropertyType,
propertyHelper.Name,
key.ModelType);
var attributes = ModelAttributes.GetAttributesForProperty(
key.ModelType,
propertyHelper.Property);
var propertyEntry = new DefaultMetadataDetails(propertyKey, attributes);
if (propertyHelper.Property.CanRead && propertyHelper.Property.GetMethod?.IsPublic == true)
{
var getter = PropertyHelper.MakeNullSafeFastPropertyGetter(propertyHelper.Property);
propertyEntry.PropertyGetter = getter;
}
if (propertyHelper.Property.CanWrite &&
propertyHelper.Property.SetMethod?.IsPublic == true &&
!key.ModelType.GetTypeInfo().IsValueType)
{
propertyEntry.PropertySetter = propertyHelper.ValueSetter;
}
propertyEntries.Add(propertyEntry);
}
return(propertyEntries.ToArray());
}
public void CreateValidationMetadata_DoesNotOverrideExistingHasValidatorsValue()
{
// Arrange
var provider = Mock.Of <IMetadataBasedModelValidatorProvider>(p => p.HasValidators(typeof(object), It.IsAny <IList <object> >()) == false);
var validationProviders = new IModelValidatorProvider[]
{
new DefaultModelValidatorProvider(),
provider,
};
var metadataProvider = new HasValidatorsValidationMetadataProvider(validationProviders);
var key = ModelMetadataIdentity.ForType(typeof(object));
var modelAttributes = new ModelAttributes(new object[0], new object[0], new object[0]);
var context = new ValidationMetadataProviderContext(key, modelAttributes);
// Initialize this value.
context.ValidationMetadata.HasValidators = true;
// Act
metadataProvider.CreateValidationMetadata(context);
// Assert
Assert.True(context.ValidationMetadata.HasValidators);
}
public void GetAttributesForParameter_SomeAttributes()
{
// Arrange & Act
var attributes = ModelAttributes.GetAttributesForParameter(
typeof(MethodWithParamAttributesType)
.GetMethod(nameof(MethodWithParamAttributesType.Method))
.GetParameters()[1]);
// Assert
Assert.Collection(
// Take(2) to ignore ComVisibleAttribute, SerializableAttribute, ... on int.
attributes.Attributes.Take(2),
attribute => Assert.IsType <RequiredAttribute>(attribute),
attribute => Assert.IsType <RangeAttribute>(attribute));
Assert.Collection(
attributes.ParameterAttributes,
attribute => Assert.IsType <RequiredAttribute>(attribute),
attribute => Assert.IsType <RangeAttribute>(attribute));
Assert.Null(attributes.PropertyAttributes);
Assert.Collection(
// Take(1) because the attribute or attributes after SerializableAttribute are framework-specific.
attributes.TypeAttributes.Take(1),
attribute => Assert.IsType <SerializableAttribute>(attribute));
}
/// <summary>
/// Creates the <see cref="DefaultMetadataDetailsCache"/> entries for the properties of a model
/// <see cref="Type"/>.
/// </summary>
/// <param name="key">
/// The <see cref="ModelMetadataIdentity"/> identifying the model <see cref="Type"/>.
/// </param>
/// <returns>A cache object for each property of the model <see cref="Type"/>.</returns>
/// <remarks>
/// The results of this method will be cached and used to satisfy calls to
/// <see cref="GetMetadataForProperties(Type)"/>. Override this method to provide a different
/// set of property data.
/// </remarks>
protected virtual DefaultMetadataDetailsCache[] CreatePropertyCacheEntries([NotNull] ModelMetadataIdentity key)
{
var propertyHelpers = PropertyHelper.GetProperties(key.ModelType);
var propertyEntries = new List <DefaultMetadataDetailsCache>(propertyHelpers.Length);
for (var i = 0; i < propertyHelpers.Length; i++)
{
var propertyHelper = propertyHelpers[i];
if (propertyHelper.Property.DeclaringType != key.ModelType)
{
// If this property was declared on a base type then look for the definition closest to the
// the model type to see if we should include it.
var ignoreProperty = false;
// Walk up the hierarchy until we find the type that actally declares this
// PropertyInfo.
var currentType = key.ModelType.GetTypeInfo();
while (currentType != propertyHelper.Property.DeclaringType.GetTypeInfo())
{
// We've found a 'more proximal' public definition
var declaredProperty = currentType.GetDeclaredProperty(propertyHelper.Name);
if (declaredProperty != null)
{
ignoreProperty = true;
break;
}
currentType = currentType.BaseType.GetTypeInfo();
}
if (ignoreProperty)
{
// There's a better definition, ignore this.
continue;
}
}
var propertyKey = ModelMetadataIdentity.ForProperty(
propertyHelper.Property.PropertyType,
propertyHelper.Name,
key.ModelType);
var attributes = new List <object>(ModelAttributes.GetAttributesForProperty(
key.ModelType,
propertyHelper.Property));
var propertyEntry = new DefaultMetadataDetailsCache(propertyKey, attributes);
if (propertyHelper.Property.CanRead && propertyHelper.Property.GetMethod?.IsPrivate == true)
{
propertyEntry.PropertyAccessor = PropertyHelper.MakeFastPropertyGetter(propertyHelper.Property);
}
if (propertyHelper.Property.CanWrite && propertyHelper.Property.SetMethod?.IsPrivate == true)
{
propertyEntry.PropertySetter = PropertyHelper.MakeFastPropertySetter(propertyHelper.Property);
}
propertyEntries.Add(propertyEntry);
}
return(propertyEntries.ToArray());
}
/// <summary>
/// Creates the <see cref="DefaultMetadataDetailsCache"/> entry for a model <see cref="Type"/>.
/// </summary>
/// <param name="key">
/// The <see cref="ModelMetadataIdentity"/> identifying the model <see cref="Type"/>.
/// </param>
/// <returns>A cache object for the model <see cref="Type"/>.</returns>
/// <remarks>
/// The results of this method will be cached and used to satisfy calls to
/// <see cref="GetMetadataForType(Type)"/>. Override this method to provide a different
/// set of attributes.
/// </remarks>
protected virtual DefaultMetadataDetailsCache CreateTypeCacheEntry([NotNull] ModelMetadataIdentity key)
{
var attributes = new List <object>(ModelAttributes.GetAttributesForType(key.ModelType));
return(new DefaultMetadataDetailsCache(key, attributes));
}
public async void Post([FromBody] ModelAttributes value)
{
await CreateBucket();
await CreateActivity();
await CreateWorkItem(value);
}
// <summary>
// Creates WorkItem
// </summary>
private async Task <IActionResult> CreateWorkItem(ModelAttributes param)
{
// OAuth token
dynamic oauth = await OAuthController.GetInternalAsync();
string bucketkey = "inventorilogicda" + nickName.ToLower();
string qualifiedActivityId = string.Format("{0}.{1}+{2}", nickName, ACTIVITY_NAME, ALIAS);
// input json
dynamic inputJson = new JObject();
inputJson.Material = param.color;
inputJson.Diameter = param.diameter;
inputJson.Spoke_Design = param.rim;
inputJson.Width = param.width;
inputJson.InputIPT = "RIM.ipt";
inputJson.InputIDW = "RIM.idw";
XrefTreeArgument inputJsonArgument = new XrefTreeArgument()
{
Url = "data:application/json, " + ((JObject)inputJson).ToString(Formatting.None).Replace("\"", "'")
};
// output IPT file
XrefTreeArgument outputIPTFileArgument = new XrefTreeArgument()
{
Url = string.Format("https://developer.api.autodesk.com/oss/v2/buckets/{0}/objects/{1}", bucketkey, outputIPTFile),
Verb = Verb.Put,
Headers = new Dictionary <string, string>()
{
{ "Authorization", "Bearer " + oauth.access_token }
}
};
// output IDW file
XrefTreeArgument outputIDWFileArgument = new XrefTreeArgument()
{
Url = string.Format("https://developer.api.autodesk.com/oss/v2/buckets/{0}/objects/{1}", bucketkey, outputIDWFile),
Verb = Verb.Put,
Headers = new Dictionary <string, string>()
{
{ "Authorization", "Bearer " + oauth.access_token }
}
};
// output PDF file
XrefTreeArgument outputPDFFileArgument = new XrefTreeArgument()
{
Url = string.Format("https://developer.api.autodesk.com/oss/v2/buckets/{0}/objects/{1}", bucketkey, outputPDFile),
Verb = Verb.Put,
Headers = new Dictionary <string, string>()
{
{ "Authorization", "Bearer " + oauth.access_token }
}
};
string callbackUrl = string.Format("{0}/api/forge/callback/designautomation?id={1}", OAuthController.GetAppSetting("FORGE_WEBHOOK_URL"), param.browserconnectionId);
WorkItem workItemSpec = new WorkItem()
{
ActivityId = qualifiedActivityId,
Arguments = new Dictionary <string, IArgument>()
{
{ "inputJson", inputJsonArgument },
{ "ResultIPT", outputIPTFileArgument },
{ "ResultIDW", outputIDWFileArgument },
{ "ResultPDF", outputPDFFileArgument },
{ "onComplete", new XrefTreeArgument {
Verb = Verb.Post, Url = callbackUrl
} }
}
};
WorkItemStatus workItemStatus = await _designAutomation.CreateWorkItemAsync(workItemSpec);
return(Ok(new { WorkItemId = workItemStatus.Id }));
}
