/// <summary>
/// Gets the property info for the resource property declared on this type.
/// </summary>
/// <param name="resourceType">The resource type to get the property on.</param>
/// <param name="resourceProperty">Resource property instance to get the property info for.</param>
/// <returns>Returns the PropertyInfo object for the specified resource property.</returns>
internal PropertyInfo GetPropertyInfo(ResourceType resourceType, ResourceProperty resourceProperty)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(resourceType != null, "resourceType != null");
Debug.Assert(resourceProperty != null, "resourceProperty != null");
Debug.Assert(resourceProperty.CanReflectOnInstanceTypeProperty, "resourceProperty.CanReflectOnInstanceTypeProperty");
Debug.Assert(resourceType.Properties.Contains(resourceProperty), "The resourceType does not define the specified resourceProperty.");
if (this.propertyInfosDeclaredOnThisType == null)
{
this.propertyInfosDeclaredOnThisType = new Dictionary<ResourceProperty, PropertyInfo>(ReferenceEqualityComparer<ResourceProperty>.Instance);
}
PropertyInfo propertyInfo;
if (!this.propertyInfosDeclaredOnThisType.TryGetValue(resourceProperty, out propertyInfo))
{
BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
propertyInfo = resourceType.InstanceType.GetProperty(resourceProperty.Name, bindingFlags);
if (propertyInfo == null)
{
throw new ODataException(Strings.PropertyInfoResourceTypeAnnotation_CannotFindProperty(resourceType.FullName, resourceType.InstanceType, resourceProperty.Name));
}
this.propertyInfosDeclaredOnThisType.Add(resourceProperty, propertyInfo);
}
Debug.Assert(propertyInfo != null, "propertyInfo != null");
return propertyInfo;
}
/// <summary>
/// Compute the result type of a binary operator based on the type of its operands and the operator kind.
/// </summary>
/// <param name="type">The type of the operators.</param>
/// <param name="operatorKind">The kind of operator.</param>
/// <returns>The result type of the binary operator.</returns>
internal static ResourceType GetBinaryOperatorResultType(ResourceType type, BinaryOperatorKind operatorKind)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(type != null, "type != null");
switch (operatorKind)
{
case BinaryOperatorKind.Or: // fall through
case BinaryOperatorKind.And: // fall through
case BinaryOperatorKind.Equal: // fall through
case BinaryOperatorKind.NotEqual: // fall through
case BinaryOperatorKind.GreaterThan: // fall through
case BinaryOperatorKind.GreaterThanOrEqual: // fall through
case BinaryOperatorKind.LessThan: // fall through
case BinaryOperatorKind.LessThanOrEqual:
Type resultType = Nullable.GetUnderlyingType(type.InstanceType) == null
? typeof(bool)
: typeof(bool?);
return ResourceType.GetPrimitiveResourceType(resultType);
case BinaryOperatorKind.Add: // fall through
case BinaryOperatorKind.Subtract: // fall through
case BinaryOperatorKind.Multiply: // fall through
case BinaryOperatorKind.Divide: // fall through
case BinaryOperatorKind.Modulo:
return type;
default:
throw new ODataException(Strings.General_InternalError(InternalErrorCodes.QueryNodeUtils_BinaryOperatorResultType_UnreachableCodepath));
}
}
/// <summary>
/// Writes the custom mapped EPM properties to an XML writer which is expected to be positioned such to write
/// a child element of the entry element.
/// </summary>
/// <param name="writer">The XmlWriter to write to.</param>
/// <param name="epmTargetTree">The EPM target tree to use.</param>
/// <param name="epmValueCache">The entry properties value cache to use to access the properties.</param>
/// <param name="resourceType">The resource type of the entry.</param>
/// <param name="metadata">The metadata provider to use.</param>
internal static void WriteEntryEpm(
XmlWriter writer,
EpmTargetTree epmTargetTree,
EntryPropertiesValueCache epmValueCache,
ResourceType resourceType,
DataServiceMetadataProviderWrapper metadata)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(writer != null, "writer != null");
Debug.Assert(epmTargetTree != null, "epmTargetTree != null");
Debug.Assert(epmValueCache != null, "epmValueCache != null");
Debug.Assert(resourceType != null, "For any EPM to exist the metadata must be available.");
// If there are no custom mappings, just return null.
EpmTargetPathSegment customRootSegment = epmTargetTree.NonSyndicationRoot;
Debug.Assert(customRootSegment != null, "EPM Target tree must always have non-syndication root.");
if (customRootSegment.SubSegments.Count == 0)
{
return;
}
foreach (EpmTargetPathSegment targetSegment in customRootSegment.SubSegments)
{
Debug.Assert(!targetSegment.IsAttribute, "Target segments under the custom root must be for elements only.");
string alreadyDeclaredPrefix = null;
WriteElementEpm(writer, targetSegment, epmValueCache, resourceType, metadata, ref alreadyDeclaredPrefix);
}
}
public bool Extract(Expression tree, IQueryable<DSResource> resourceRoot, ResourceType resourceType, EntityMetadata entityMetadata)
{
this.resourceRoot = resourceRoot;
this.entityMetadata = entityMetadata;
this.navigationProperty = null;
this.referredEntityKeys = new Dictionary<string, object>();
this.referringEntityKeys = new Dictionary<string, object>();
this.currentState = ReferredResourceExtractor.ExtractionState.ExtractingReferredEntityInfo;
this.Visit(tree);
if (this.currentState == ReferredResourceExtractor.ExtractionState.ExtractingReferringEntityInfo)
{
DSResource dSResource = ResourceTypeExtensions.CreateKeyOnlyResource(resourceType, this.referringEntityKeys);
if (dSResource != null)
{
this.ReferredResource = ResourceTypeExtensions.CreateKeyOnlyResource(this.navigationProperty.ResourceType, this.referredEntityKeys);
if (this.ReferredResource != null)
{
this.currentState = ReferredResourceExtractor.ExtractionState.ExtractionDone;
}
}
}
if (this.currentState != ReferredResourceExtractor.ExtractionState.ExtractionDone)
{
this.currentState = ReferredResourceExtractor.ExtractionState.ExtractionFailed;
}
return this.currentState == ReferredResourceExtractor.ExtractionState.ExtractionDone;
}
public CollectionResourceTypeSerializer(ResourceType resourceType) : base(resourceType)
{
object[] resourceTypeKind = new object[2];
resourceTypeKind[0] = resourceType.ResourceTypeKind;
resourceTypeKind[1] = ResourceTypeKind.Collection;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.Collection, new ExceptionHelpers.MessageLoader(SerializerBase.GetInvalidArgMessage), resourceTypeKind);
}
public static TableResourceContainer GetUtilityRowResourceContainer(string accountName, string tableName)
{
System.Data.Services.Providers.ResourceType resourceType = new System.Data.Services.Providers.ResourceType(typeof(UtilityRow), ResourceTypeKind.EntityType, null, accountName, tableName, false)
{
CanReflectOnInstanceType = false,
IsOpenType = true
};
ResourceProperty utilityRowResourceProperty = new UtilityRowResourceProperty("PartitionKey", ResourcePropertyKind.Primitive | ResourcePropertyKind.Key, System.Data.Services.Providers.ResourceType.GetPrimitiveResourceType(typeof(string)))
{
CanReflectOnInstanceTypeProperty = false
};
resourceType.AddProperty(utilityRowResourceProperty);
ResourceProperty resourceProperty = new UtilityRowResourceProperty("RowKey", ResourcePropertyKind.Primitive | ResourcePropertyKind.Key, System.Data.Services.Providers.ResourceType.GetPrimitiveResourceType(typeof(string)))
{
CanReflectOnInstanceTypeProperty = false
};
resourceType.AddProperty(resourceProperty);
ResourceProperty utilityRowResourceProperty1 = new UtilityRowResourceProperty("Timestamp", ResourcePropertyKind.Primitive | ResourcePropertyKind.ETag, System.Data.Services.Providers.ResourceType.GetPrimitiveResourceType(typeof(DateTime)))
{
CanReflectOnInstanceTypeProperty = false
};
resourceType.AddProperty(utilityRowResourceProperty1);
TableResourceContainer tableResourceContainer = new TableResourceContainer(tableName, resourceType);
tableResourceContainer.SetReadOnly();
return(tableResourceContainer);
}
public static DSResource CreateResourceWithKeyAndReferenceSetCmdlets(ResourceType resourceType, Dictionary<string, object> keyProperties, EntityMetadata entityMetadata)
{
DSResource dSResource = ResourceTypeExtensions.CreateKeyOnlyResource(resourceType, keyProperties);
if (dSResource != null)
{
PSEntityMetadata pSEntityMetadatum = entityMetadata as PSEntityMetadata;
ReadOnlyCollection<ResourceProperty> properties = resourceType.Properties;
foreach (ResourceProperty resourceProperty in properties.Where<ResourceProperty>((ResourceProperty it) => (it.Kind & ResourcePropertyKind.ResourceSetReference) == ResourcePropertyKind.ResourceSetReference))
{
PSEntityMetadata.ReferenceSetCmdlets referenceSetCmdlet = null;
if (!pSEntityMetadatum.CmdletsForReferenceSets.TryGetValue(resourceProperty.Name, out referenceSetCmdlet) || !referenceSetCmdlet.Cmdlets.ContainsKey(CommandType.GetReference))
{
continue;
}
if (referenceSetCmdlet.GetRefHidden)
{
dSResource.SetValue(resourceProperty.Name, null);
}
else
{
PSReferencedResourceSet pSReferencedResourceSet = new PSReferencedResourceSet(resourceProperty, resourceType);
dSResource.SetValue(resourceProperty.Name, pSReferencedResourceSet);
}
}
return dSResource;
}
else
{
return null;
}
}
protected void ApplyProperty(ODataProperty property, ResourceType resourceType, object resource)
{
ResourceType type;
string name = property.Name;
ResourceProperty resourceProperty = resourceType.TryResolvePropertyName(name);
if (resourceProperty == null)
{
type = null;
}
else
{
if (resourceProperty.Kind == ResourcePropertyKind.Stream)
{
return;
}
if (base.Update && resourceProperty.IsOfKind(ResourcePropertyKind.Key))
{
return;
}
type = resourceProperty.ResourceType;
}
object propertyValue = this.ConvertValue(property.Value, ref type);
if (resourceProperty == null)
{
Deserializer.SetOpenPropertyValue(resource, name, propertyValue, base.Service);
}
else
{
Deserializer.SetPropertyValue(resourceProperty, resource, propertyValue, base.Service);
}
}
/// <summary>
/// Constructor creates contained serializers
/// </summary>
/// <param name="resourceType">Resource type being serialized</param>
/// <param name="element">Instance of <paramref name="resourceType"/></param>
internal EpmContentDeSerializer(ResourceType resourceType, object element)
{
Debug.Assert(resourceType.HasEntityPropertyMappings == true, "Must have entity property mappings to instantiate EpmContentDeSerializer");
this.resourceType = resourceType;
this.element = element;
this.resourceType.EnsureEpmInfoAvailability();
}
private static ResourceType GetReturnTypeFromResultType(ResourceType resultType, ServiceOperationResultKind resultKind)
{
if (((resultKind == ServiceOperationResultKind.Void) && (resultType != null)) || ((resultKind != ServiceOperationResultKind.Void) && (resultType == null)))
{
throw new ArgumentException(System.Data.Services.Strings.ServiceOperation_ResultTypeAndKindMustMatch("resultKind", "resultType", ServiceOperationResultKind.Void));
}
if ((resultType != null) && (resultType.ResourceTypeKind == ResourceTypeKind.Collection))
{
throw new ArgumentException(System.Data.Services.Strings.ServiceOperation_InvalidResultType(resultType.FullName));
}
if ((resultType != null) && (resultType.ResourceTypeKind == ResourceTypeKind.EntityCollection))
{
throw new ArgumentException(System.Data.Services.Strings.ServiceOperation_InvalidResultType(resultType.FullName));
}
if (resultType == null)
{
return null;
}
if (((resultType.ResourceTypeKind == ResourceTypeKind.Primitive) || (resultType.ResourceTypeKind == ResourceTypeKind.ComplexType)) && ((resultKind == ServiceOperationResultKind.Enumeration) || (resultKind == ServiceOperationResultKind.QueryWithMultipleResults)))
{
return ResourceType.GetCollectionResourceType(resultType);
}
if ((resultType.ResourceTypeKind == ResourceTypeKind.EntityType) && ((resultKind == ServiceOperationResultKind.Enumeration) || (resultKind == ServiceOperationResultKind.QueryWithMultipleResults)))
{
return ResourceType.GetEntityCollectionResourceType(resultType);
}
return resultType;
}
internal string GetActionTitleSegmentByResourceType(ResourceType resourceType, string containerName)
{
string str;
if (!this.actionTitleSegmentByResourceType.TryGetValue(resourceType, out str))
{
bool flag = false;
if (resourceType.IsOpenType)
{
flag = true;
}
else
{
foreach (ResourceProperty property in resourceType.Properties)
{
if (property.Name.Equals(this.Name, StringComparison.Ordinal))
{
flag = true;
break;
}
}
}
str = flag ? (containerName + "." + this.Name) : this.Name;
this.actionTitleSegmentByResourceType[resourceType] = str;
}
return str;
}
public PrimitiveTypeSerializer(ResourceType resourceType, ResourceProperty resourceProperty) : base(resourceType)
{
object defaultValue;
object[] resourceTypeKind = new object[2];
resourceTypeKind[0] = resourceType.ResourceTypeKind;
resourceTypeKind[1] = ResourceTypeKind.Primitive;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.Primitive, new ExceptionHelpers.MessageLoader(SerializerBase.GetInvalidArgMessage), resourceTypeKind);
this.defaultValue = null;
if (resourceProperty != null)
{
if ((resourceProperty.Kind & ResourcePropertyKind.Primitive) != ResourcePropertyKind.Primitive || resourceProperty.ResourceType.InstanceType != resourceType.InstanceType)
{
throw new ArgumentException("resourceProperty");
}
else
{
PropertyCustomState customState = resourceProperty.GetCustomState();
PrimitiveTypeSerializer primitiveTypeSerializer = this;
if (customState != null)
{
defaultValue = customState.DefaultValue;
}
else
{
defaultValue = null;
}
primitiveTypeSerializer.defaultValue = defaultValue;
this.name = resourceProperty.Name;
}
}
}
private IEnumerable<ODataAssociationLink> GetEntityAssociationLinks(ResourceType currentResourceType, Uri relativeUri, IEnumerable<ProjectionNode> projectionNodesForCurrentResourceType)
{
if (!base.Service.Configuration.DataServiceBehavior.ShouldIncludeAssociationLinksInResponse)
{
return null;
}
List<ODataAssociationLink> list = new List<ODataAssociationLink>(currentResourceType.Properties.Count);
if (projectionNodesForCurrentResourceType == null)
{
foreach (ResourceProperty property in base.Provider.GetResourceSerializableProperties(base.CurrentContainer, currentResourceType))
{
if (property.TypeKind == ResourceTypeKind.EntityType)
{
list.Add(GetAssociationLink(relativeUri, property));
}
}
return list;
}
foreach (ProjectionNode node in projectionNodesForCurrentResourceType)
{
string propertyName = node.PropertyName;
ResourceProperty navigationProperty = node.TargetResourceType.TryResolvePropertyName(propertyName);
if (((navigationProperty != null) && (navigationProperty.TypeKind == ResourceTypeKind.EntityType)) && (list != null))
{
list.Add(GetAssociationLink(relativeUri, navigationProperty));
}
}
return list;
}
public ICommand GetCommand(CommandType commandType, UserContext userContext, ResourceType entityType, EntityMetadata entityMetadata, string membershipId)
{
if (entityType.Name == "CommandInvocation")
{
CommandType commandType1 = commandType;
switch (commandType1)
{
case CommandType.Create:
case CommandType.Read:
case CommandType.Delete:
{
return new GICommand(commandType, this.runspaceStore, entityType, userContext, membershipId);
}
case CommandType.Update:
{
throw new NotImplementedException();
}
default:
{
throw new NotImplementedException();
}
}
}
else
{
throw new NotImplementedException();
}
}
public MovableWhereFinder(Expression tree, IQueryable<DSResource> resourceRoot, ResourceType baseResourceType)
{
this.resourceRoot = resourceRoot;
this.baseResourceType = baseResourceType;
this.MovableWhereExpression = null;
this.Visit(tree);
}
private IEdmEntityType AddEntityType(ResourceType resourceType, string resourceTypeNamespace)
{
Action<MetadataProviderEdmEntityType> propertyLoadAction = delegate (MetadataProviderEdmEntityType type) {
IEnumerable<ResourceProperty> allVisiblePropertiesDeclaredInThisType = this.GetAllVisiblePropertiesDeclaredInThisType(resourceType);
if (allVisiblePropertiesDeclaredInThisType != null)
{
foreach (ResourceProperty property in allVisiblePropertiesDeclaredInThisType)
{
IEdmProperty property2 = this.CreateProperty(type, property);
if (property.IsOfKind(ResourcePropertyKind.Key))
{
type.AddKeys(new IEdmStructuralProperty[] { (IEdmStructuralProperty) property2 });
}
}
}
};
MetadataProviderEdmEntityType schemaType = new MetadataProviderEdmEntityType(resourceTypeNamespace, resourceType.Name, (resourceType.BaseType != null) ? ((IEdmEntityType) this.EnsureSchemaType(resourceType.BaseType)) : null, resourceType.IsAbstract, resourceType.IsOpenType, propertyLoadAction);
this.CacheSchemaType(schemaType);
if (resourceType.IsMediaLinkEntry && ((resourceType.BaseType == null) || !resourceType.BaseType.IsMediaLinkEntry))
{
this.SetHasDefaultStream(schemaType, true);
}
if (resourceType.HasEntityPropertyMappings)
{
MetadataProviderUtils.ConvertEntityPropertyMappings(this, resourceType, schemaType);
}
MetadataProviderUtils.ConvertCustomAnnotations(this, resourceType.CustomAnnotations, schemaType);
return schemaType;
}
private ResourceType(Type type, ResourceType baseType, string namespaceName, string name, bool isAbstract)
{
this.lockPropertiesLoad = new object();
this.propertyInfosDeclaredOnThisType = new Dictionary<ResourceProperty, ResourcePropertyInfo>(ReferenceEqualityComparer<ResourceProperty>.Instance);
this.schemaVersion = ~MetadataEdmSchemaVersion.Version1Dot0;
WebUtil.CheckArgumentNull<Type>(type, "type");
WebUtil.CheckArgumentNull<string>(name, "name");
this.name = name;
this.namespaceName = namespaceName ?? string.Empty;
if ((name == "String") && object.ReferenceEquals(namespaceName, "Edm"))
{
this.fullName = "Edm.String";
}
else
{
this.fullName = string.IsNullOrEmpty(namespaceName) ? name : (namespaceName + "." + name);
}
this.type = type;
this.abstractType = isAbstract;
this.canReflectOnInstanceType = true;
if (baseType != null)
{
this.baseType = baseType;
}
}
private IEnumerable<ODataProperty> GetAllEntityProperties(object customObject, ResourceType currentResourceType, Uri relativeUri)
{
List<ODataProperty> list = new List<ODataProperty>(currentResourceType.Properties.Count);
foreach (ResourceProperty property in base.Provider.GetResourceSerializableProperties(base.CurrentContainer, currentResourceType))
{
if (property.TypeKind != ResourceTypeKind.EntityType)
{
list.Add(this.GetODataPropertyForEntityProperty(customObject, currentResourceType, relativeUri, property));
}
}
if (currentResourceType.IsOpenType)
{
foreach (KeyValuePair<string, object> pair in base.Provider.GetOpenPropertyValues(customObject))
{
string key = pair.Key;
if (string.IsNullOrEmpty(key))
{
throw new DataServiceException(500, System.Data.Services.Strings.Syndication_InvalidOpenPropertyName(currentResourceType.FullName));
}
list.Add(this.GetODataPropertyForOpenProperty(key, pair.Value));
}
if (!currentResourceType.HasEntityPropertyMappings || (this.contentFormat == ODataFormat.VerboseJson))
{
return list;
}
HashSet<string> propertiesLookup = new HashSet<string>(from p in list select p.Name);
foreach (EpmSourcePathSegment segment in from p in currentResourceType.EpmSourceTree.Root.SubProperties
where !propertiesLookup.Contains(p.PropertyName)
select p)
{
list.Add(this.GetODataPropertyForOpenProperty(segment.PropertyName, base.Provider.GetOpenPropertyValue(customObject, segment.PropertyName)));
}
}
return list;
}
public IEnumerable<ResourceType> GetDerivedTypes(
ResourceType resourceType
)
{
// We don't support type inheritance yet
yield break;
}
/// <summary>
/// Converts the given value to the ATOM string representation
/// and uses the writer to write it.
/// </summary>
/// <param name="writer">The writer to write the stringified value.</param>
/// <param name="value">The value to be written.</param>
/// <param name="expectedType">The expected resource type of the value or null if no metadata is available.</param>
internal static void WritePrimitiveValue(XmlWriter writer, object value, ResourceType expectedType)
{
DebugUtils.CheckNoExternalCallers();
Debug.Assert(value != null, "value != null");
string result;
bool preserveWhitespace;
if (!TryConvertPrimitiveToString(value, out result, out preserveWhitespace))
{
throw new ODataException(Strings.AtomValueUtils_CannotConvertValueToAtomPrimitive(value.GetType().FullName));
}
if (expectedType != null)
{
ValidationUtils.ValidateIsExpectedPrimitiveType(value, expectedType);
}
if (preserveWhitespace)
{
writer.WriteAttributeString(
AtomConstants.XmlNamespacePrefix,
AtomConstants.XmlSpaceAttributeName,
AtomConstants.XmlNamespace,
AtomConstants.XmlPreserveSpaceAttributeValue);
}
writer.WriteString(result);
}
public ReferenceTypeSerializer(ResourceType referringResourceType, ResourceProperty resourceProperty) : base(resourceProperty.ResourceType)
{
if (resourceProperty.ResourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
object[] name = new object[1];
name[0] = resourceProperty.Name;
referringResourceType.ThrowIfNull("referringResourceType", new ParameterExtensions.MessageLoader(SerializerBase.GetReferringResourceTypeCannotNullMessage), name);
DataContext currentContext = DataServiceController.Current.GetCurrentContext();
if (currentContext != null)
{
PSEntityMetadata entityMetadata = currentContext.UserSchema.GetEntityMetadata(referringResourceType) as PSEntityMetadata;
PSEntityMetadata.ReferenceSetCmdlets referenceSetCmdlet = null;
if (!entityMetadata.CmdletsForReferenceSets.TryGetValue(resourceProperty.Name, out referenceSetCmdlet))
{
this.referencePropertyType = PSEntityMetadata.ReferenceSetCmdlets.ReferencePropertyType.Instance;
}
else
{
this.referencePropertyType = referenceSetCmdlet.PropertyType;
return;
}
}
return;
}
else
{
throw new ArgumentException("resourceType");
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="returnType">The return type of the function.</param>
/// <param name="argumentTypes">The argument types for this function signature.</param>
private BuiltInFunctionSignature(ResourceType returnType, params ResourceType[] argumentTypes)
: base(argumentTypes)
{
Debug.Assert(returnType != null, "returnType != null");
Debug.Assert(returnType.ResourceTypeKind == ResourceTypeKind.Primitive, "Only primitive values are supported as built-in function return types.");
this.returnType = returnType;
}
public ReferredEntityInstance(DSResource resource, UserContext userContext, ResourceType type, EntityMetadata metadata, string membershipId)
{
this.userContext = userContext;
this.resourceType = type;
this.metadata = metadata;
this.membershipId = membershipId;
this.resource = resource;
}
public ResourceAssociationSet GetResourceAssociationSet(
ResourceSet resourceSet,
ResourceType resourceType,
ResourceProperty resourceProperty)
{
// resourceProperty.GetAnnotation().ResourceAssociationSet;
return resourceProperty.CustomState as ResourceAssociationSet;
}
internal EntityCollectionResourceType(ResourceType itemType) : base(GetInstanceType(itemType), ResourceTypeKind.EntityCollection, string.Empty, GetName(itemType))
{
if (itemType.ResourceTypeKind != ResourceTypeKind.EntityType)
{
throw new ArgumentException(Strings.ResourceType_CollectionItemCanBeOnlyEntity);
}
this.itemType = itemType;
}
public ServiceOperationParameter(string name, ResourceType parameterType) : base(name, parameterType)
{
WebUtil.CheckArgumentNull<ResourceType>(parameterType, "parameterType");
if (parameterType.ResourceTypeKind != ResourceTypeKind.Primitive)
{
throw new ArgumentException(Strings.ServiceOperationParameter_TypeNotSupported(name, parameterType.FullName), "parameterType");
}
}
public EntityPropertyMappingInfo(EntityPropertyMappingAttribute attribute, ResourceType definingType, ResourceType actualPropertyType, bool isEFProvider)
{
this.isEFProvider = isEFProvider;
this.attribute = attribute;
this.definingType = definingType;
this.actualPropertyType = actualPropertyType;
this.propertyValuePath = attribute.SourcePath.Split(new char[] { '/' });
this.isSyndicationMapping = this.attribute.TargetSyndicationItem != SyndicationItemProperty.CustomProperty;
}
internal void AddComplexCollectionProperty(ResourceType resourceType, string name, ResourceType complexType)
{
CollectionResourceType collectionResourceType = ResourceType.GetCollectionResourceType(complexType);
ResourceProperty resourcePropertyWithDescription = new ResourcePropertyWithDescription(name, ResourcePropertyKind.Collection, collectionResourceType);
resourcePropertyWithDescription.CanReflectOnInstanceTypeProperty = false;
PropertyCustomState propertyCustomState = new PropertyCustomState();
resourcePropertyWithDescription.CustomState = propertyCustomState;
resourceType.AddProperty(resourcePropertyWithDescription);
}
public GICommand(CommandType commandType, ExclusiveItemStore<PSRunspace, UserContext> runspaceStore, ResourceType entityType, UserContext userContext, string membershipId)
{
this.commandType = commandType;
this.runspaceStore = runspaceStore;
this.entityType = entityType;
this.userContext = userContext;
this.membershipId = membershipId;
this.parameters = new Dictionary<string, object>();
}
public EntityTypeSerializer(ResourceType resourceType, bool serializeKeyOnly = false) : base(resourceType)
{
object[] resourceTypeKind = new object[2];
resourceTypeKind[0] = resourceType.ResourceTypeKind;
resourceTypeKind[1] = ResourceTypeKind.EntityType;
ExceptionHelpers.ThrowArgumentExceptionIf("resourceType", resourceType.ResourceTypeKind != ResourceTypeKind.EntityType, new ExceptionHelpers.MessageLoader(SerializerBase.GetInvalidArgMessage), resourceTypeKind);
this.serializeKeyOnly = serializeKeyOnly;
this.TestHookEntityMetadata = null;
}
/// <summary>
/// Writes an EPM element target.
/// </summary>
/// <param name="writer">The writer to write to.</param>
/// <param name="targetSegment">The target segment describing the element to write.</param>
/// <param name="epmValueCache">The entry properties value cache to use to access the properties.</param>
/// <param name="resourceType">The resource type of the entry.</param>
/// <param name="metadata">The metadata provider to use.</param>
/// <param name="alreadyDeclaredPrefix">The name of the prefix if it was already declared.</param>
private static void WriteElementEpm(
XmlWriter writer,
EpmTargetPathSegment targetSegment,
EntryPropertiesValueCache epmValueCache,
ResourceType resourceType,
DataServiceMetadataProviderWrapper metadata,
ref string alreadyDeclaredPrefix)
{
Debug.Assert(writer != null, "writer != null");
Debug.Assert(targetSegment != null && !targetSegment.IsAttribute, "Only element target segments are supported by this method.");
// If the prefix is null, the WCF DS will still write it as the default namespace, so we need it to be an empty string.
string elementPrefix = targetSegment.SegmentNamespacePrefix ?? string.Empty;
writer.WriteStartElement(elementPrefix, targetSegment.SegmentName, targetSegment.SegmentNamespaceUri);
// Write out the declaration explicitly only if the prefix is not empty (just like the WCF DS does)
if (elementPrefix.Length > 0)
{
WriteNamespaceDeclaration(writer, targetSegment, ref alreadyDeclaredPrefix);
}
// Serialize the sub segment attributes first
foreach (EpmTargetPathSegment subSegment in targetSegment.SubSegments)
{
if (subSegment.IsAttribute)
{
WriteAttributeEpm(writer, subSegment, epmValueCache, resourceType, metadata, ref alreadyDeclaredPrefix);
}
}
if (targetSegment.HasContent)
{
Debug.Assert(!targetSegment.SubSegments.Any(subSegment => !subSegment.IsAttribute), "If the segment has a content, it must not have any element children.");
string textPropertyValue = GetEntryPropertyValueAsText(targetSegment, epmValueCache, resourceType, metadata);
// TODO: In V3 we should check for textPropertyValue == null and write out the m:null in that case.
Debug.Assert(textPropertyValue != null, "Null property value should not get here, the GetEntryPropertyValueAsText should take care of that for now.");
writer.WriteString(textPropertyValue);
}
else
{
// Serialize the sub segment elements now
foreach (EpmTargetPathSegment subSegment in targetSegment.SubSegments)
{
if (!subSegment.IsAttribute)
{
WriteElementEpm(writer, subSegment, epmValueCache, resourceType, metadata, ref alreadyDeclaredPrefix);
}
}
}
// Close the element
writer.WriteEndElement();
}
public static TableResourceContainer GetUtilityTableResourceContainer(string accountName, bool PremiumTableAccountRequest)
{
System.Data.Services.Providers.ResourceType resourceType = new System.Data.Services.Providers.ResourceType(typeof(UtilityTable), ResourceTypeKind.EntityType, null, accountName, "Tables", false)
{
CanReflectOnInstanceType = false,
IsOpenType = true
};
if (PremiumTableAccountRequest)
{
resourceType.AddProperty(TableResourceContainer.ProvisionedIOPSProperty);
resourceType.AddProperty(TableResourceContainer.TableStatusProperty);
resourceType.AddProperty(TableResourceContainer.RequestedIOPSProperty);
}
ResourceProperty utilityTableResourceProperty = new UtilityTableResourceProperty("TableName", ResourcePropertyKind.Primitive | ResourcePropertyKind.Key, System.Data.Services.Providers.ResourceType.GetPrimitiveResourceType(typeof(string)))
{
CanReflectOnInstanceTypeProperty = false
};
resourceType.AddProperty(utilityTableResourceProperty);
TableResourceContainer tableResourceContainer = new TableResourceContainer("Tables", resourceType);
tableResourceContainer.SetReadOnly();
return(tableResourceContainer);
}
public UtilityRowResourceProperty(string name, ResourcePropertyKind kind, System.Data.Services.Providers.ResourceType propertyResourceType, ResourceSet targetContainer) : base(name, kind, propertyResourceType)
{
}
/// <summary> /// Gets the ResourceAssociationSet instance when given the source association end. /// </summary> /// <param name="resourceSet">Resource set of the source association end.</param> /// <param name="resourceType">Resource type of the source association end.</param> /// <param name="resourceProperty">Resource property of the source association end.</param> /// <returns>ResourceAssociationSet instance.</returns> public abstract ResourceAssociationSet GetResourceAssociationSet(ResourceSet resourceSet, ResourceType resourceType, ResourceProperty resourceProperty);
/// <summary>
/// Find the corresponding ResourceType for a given Type, primitive or not
/// </summary>
/// <param name="knownTypes">Non-primitive types to search</param>
/// <param name="type">Type to look for</param>
/// <param name="resourceType">Corresponding ResourceType, if found</param>
/// <returns>True if type found, false otherwise</returns>
protected static bool TryGetType(IDictionary <Type, ResourceType> knownTypes, Type type, out ResourceType resourceType)
{
Debug.Assert(knownTypes != null, "knownTypes != null");
Debug.Assert(type != null, "type != null");
resourceType = ResourceType.GetPrimitiveResourceType(type);
if (resourceType == null)
{
knownTypes.TryGetValue(type, out resourceType);
}
return(resourceType != null);
}
/// <summary>
/// Returns the resource type of the given instance and validates that the instance returns a single resource.
/// </summary>
/// <param name="resource">clr instance of a resource.</param>
/// <returns>resource type of the given instance.</returns>
protected ResourceType GetSingleResource(object resource)
{
ResourceType resourceType = this.ProviderWrapper.GetResourceType(resource);
return(resourceType);
}
public ServiceOperationParameter(string name, ResourceType parameterType)
{
Contract.Requires(!string.IsNullOrEmpty(name));
Contract.Requires(parameterType.ResourceTypeKind == ((System.Data.Services.Providers.ResourceTypeKind)(2)));
}
public TableResourceContainer(string name, System.Data.Services.Providers.ResourceType elementType) : base(name, elementType)
{
}
public UtilityRowResourceProperty(string name, ResourcePropertyKind kind, System.Data.Services.Providers.ResourceType propertyResourceType) : this(name, kind, propertyResourceType, null)
{
}
public ResourceProperty(string name, ResourcePropertyKind kind, ResourceType propertyResourceType)
{
Contract.Requires(!string.IsNullOrEmpty(name));
Contract.Requires(propertyResourceType != null);
}
/// <summary>
/// Adds a new <see cref="ServiceOperation"/> based on the specified <paramref name="method"/>
/// instance.
/// </summary>
/// <param name="method">Method to expose as a service operation.</param>
/// <param name="protocolMethod">Protocol (for example HTTP) method the service operation responds to.</param>
private void AddServiceOperation(MethodInfo method, string protocolMethod)
{
Debug.Assert(method != null, "method != null");
Debug.Assert(!method.IsAbstract, "!method.IsAbstract - if method is abstract, the type is abstract - already checked");
// This method is only called for V1 providers, since in case of custom providers,
// they are suppose to load the metadata themselves.
if (this.metadata.ServiceOperations.ContainsKey(method.Name))
{
throw new InvalidOperationException(Strings.BaseServiceProvider_OverloadingNotSupported(this.Type, method));
}
bool hasSingleResult = SingleResultAttribute.MethodHasSingleResult(method);
ServiceOperationResultKind resultKind;
ResourceType resourceType = null;
if (method.ReturnType == typeof(void))
{
resultKind = ServiceOperationResultKind.Void;
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
else
{
// Load the metadata of the resource type on the fly.
// For Edm provider, it might not mean anything, but for reflection service provider, we need to
// load the metadata of the type if its used only in service operation case
Type resultType = null;
if (WebUtil.IsPrimitiveType(method.ReturnType))
{
resultKind = ServiceOperationResultKind.DirectValue;
resultType = method.ReturnType;
resourceType = ResourceType.GetPrimitiveResourceType(resultType);
}
else
{
Type queryableElement = GetGenericInterfaceElementType(method.ReturnType, IQueryableTypeFilter);
if (queryableElement != null)
{
resultKind = hasSingleResult ?
ServiceOperationResultKind.QueryWithSingleResult :
ServiceOperationResultKind.QueryWithMultipleResults;
resultType = queryableElement;
}
else
{
Type enumerableElement = GetIEnumerableElement(method.ReturnType);
if (enumerableElement != null)
{
resultKind = ServiceOperationResultKind.Enumeration;
resultType = enumerableElement;
}
else
{
resultType = method.ReturnType;
resultKind = ServiceOperationResultKind.DirectValue;
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
}
Debug.Assert(resultType != null, "resultType != null");
resourceType = ResourceType.GetPrimitiveResourceType(resultType);
if (resourceType == null)
{
resourceType = this.PopulateMetadataForType(resultType, this.TypeCache, this.ChildTypesCache, this.EntitySets.Values);
}
}
if (resourceType == null)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_UnsupportedReturnType(method, method.ReturnType));
}
if (resultKind == ServiceOperationResultKind.Enumeration && hasSingleResult)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_IEnumerableAlwaysMultiple(this.Type, method));
}
if (hasSingleResult ||
(!hasSingleResult &&
(resourceType.ResourceTypeKind == ResourceTypeKind.ComplexType ||
resourceType.ResourceTypeKind == ResourceTypeKind.Primitive)))
{
this.UpdateEdmSchemaVersion(MetadataEdmSchemaVersion.Version1Dot1);
}
}
ParameterInfo[] parametersInfo = method.GetParameters();
ServiceOperationParameter[] parameters = new ServiceOperationParameter[parametersInfo.Length];
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameterInfo = parametersInfo[i];
if (parameterInfo.IsOut || parameterInfo.IsRetval)
{
throw new InvalidOperationException(Strings.BaseServiceProvider_ParameterNotIn(method, parameterInfo));
}
ResourceType parameterType = ResourceType.GetPrimitiveResourceType(parameterInfo.ParameterType);
if (parameterType == null)
{
throw new InvalidOperationException(
Strings.BaseServiceProvider_ParameterTypeNotSupported(method, parameterInfo, parameterInfo.ParameterType));
}
string parameterName = parameterInfo.Name ?? "p" + i.ToString(CultureInfo.InvariantCulture);
parameters[i] = new ServiceOperationParameter(parameterName, parameterType);
}
ResourceSet container = null;
if (resourceType != null && resourceType.ResourceTypeKind == ResourceTypeKind.EntityType)
{
if (!this.TryFindAnyContainerForType(resourceType, out container))
{
throw new InvalidOperationException(
Strings.BaseServiceProvider_ServiceOperationMissingSingleEntitySet(method, resourceType.FullName));
}
}
ServiceOperation operation = new ServiceOperation(method.Name, resultKind, resourceType, container, protocolMethod, parameters);
operation.CustomState = method;
MimeTypeAttribute attribute = MimeTypeAttribute.GetMimeTypeAttribute(method);
if (attribute != null)
{
operation.MimeType = attribute.MimeType;
}
this.metadata.ServiceOperations.Add(method.Name, operation);
}