public void DeleteStream(object entity, DataServiceOperationContext operationContext) { var attachment = entity as Attachment; if (attachment == null) { throw new DataServiceException(500, "No such attachment"); } try { // Delete the requested file by using the key value. attachment.Person = null; attachment.PersonWithAvatar = null; attachment.Discussion = null; attachment.ArgPoint = null; var mediaData = attachment.MediaData; attachment.MediaData = null; if (mediaData != null) context.DeleteObject(mediaData); context.DeleteObject(attachment); } catch (IOException ex) { throw new DataServiceException("Error during attachment removal: ", ex); } }
public Stream GetReadStream(object entity, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { if (checkETagForEquality != null) { // This stream provider implementation does not support // ETag headers for media resources. This means that we do not track // concurrency for a media resource and last-in wins on updates. throw new DataServiceException(400, "This sample service does not support the ETag header for a media resource."); } Attachment attach = entity as Attachment; if (attach == null) { throw new DataServiceException(500, "No such attachment"); } if (attach.MediaData == null || attach.MediaData.Data == null) { throw new DataServiceException(500, "Cannot find requested media resource"); } return new MemoryStream(attach.MediaData.Data); }
public override Stream GetWriteStream(object entity, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { var attachment = entity as Attachment; var tempFile = Path.Combine(Path.GetTempPath(), attachment.Id); return new FileStream(tempFile, FileMode.Create, FileAccess.ReadWrite); }
Dictionary<string, string> GetQueryParameterBag(DataServiceOperationContext serviceOperationContext) { Dictionary<string, string> ParameterBag = null; string query = serviceOperationContext.AbsoluteRequestUri.Query; if (!string.IsNullOrEmpty(query)) { ParameterBag = new Dictionary<string, string>(); query = query.Remove(0, 1); string[] param = query.Split('&'); string paramName; string paramValue; foreach (var item in param) { //Skip OData supported parameters [see Ronald`s Comment] if (!item.StartsWith("$")) { paramName = item.Substring(0, item.IndexOf("=")); paramValue = item.Substring(item.IndexOf("=") + 1); ParameterBag.Add(paramName, paramValue); } } } return ParameterBag; }
//Named Resource using .NET Framework 4.0 public Stream GetReadStream40(object entity, ResourceProperty resourceProperty, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { vProductCatalog image = entity as vProductCatalog; //ThumbnailPhoto and LargePhoto string imageFilePath = HostingEnvironment.MapPath("~/ProductImages/" + resourceProperty.Name); if (checkETagForEquality != null) { // This stream provider implementation does not support // ETag headers for media resources. This means that we do not track // concurrency for a media resource and last-in wins on updates. throw new DataServiceException(400, "This sample service does not support the ETag header for a media resource."); } if (image == null) { throw new DataServiceException(500, "Internal Server Error."); } // Build the full path to the stored image file, which includes the entity key. string fullImageFilePath = string.Format(@"{0}\{1}.gif", imageFilePath, this.ProductPhotoID(image.ProductID)); if (!File.Exists(fullImageFilePath)) { throw new DataServiceException(500, "The image could not be found."); } // Return a stream that contains the requested file. return new FileStream(fullImageFilePath, FileMode.Open); }
private static void FixUpDataServiceUrisForCuratedFeedName( DataServiceOperationContext operationContext, string curatedFeedName) { // AVERT YOUR EYES! // This is an *evil* hack to get proper URIs into the data servive's output, e.g. /api/v2/curated-feeds/{name}. // Without this, the URIs in the data service will be wrong, and won't work if a client tried to use them. var fixedUpSeriveUri = operationContext.AbsoluteServiceUri.AbsoluteUri.Replace("/api/v2/curated-feed/", "/api/v2/curated-feeds/" + curatedFeedName + "/"); var fixedUpRequestUri = operationContext.AbsoluteRequestUri.AbsoluteUri.Replace("/api/v2/curated-feed/", "/api/v2/curated-feeds/" + curatedFeedName + "/"); // The URI needs to be fixed up both on the actual IDataService host (hostInterface) and the service host wrapper (hostWrapper) // Null checks aren't really worth much here. If it does break, it'll result in a 500 to the client. var hostInterfaceField = operationContext.GetType().GetField("hostInterface", BindingFlags.NonPublic | BindingFlags.Instance); var hostInterface = hostInterfaceField.GetValue(operationContext); var hostWrapperField = operationContext.GetType().GetField("hostWrapper", BindingFlags.NonPublic | BindingFlags.Instance); var hostWrapper = hostWrapperField.GetValue(operationContext); // Fix up the service URIs var interfaceServiceUriField = hostInterface.GetType().GetField("absoluteServiceUri", BindingFlags.NonPublic | BindingFlags.Instance); interfaceServiceUriField.SetValue(hostInterface, new Uri(fixedUpSeriveUri)); var wrapperServiceUriField = hostWrapper.GetType().GetField("absoluteServiceUri", BindingFlags.NonPublic | BindingFlags.Instance); wrapperServiceUriField.SetValue(hostWrapper, new Uri(fixedUpSeriveUri)); // Fix up the request URIs var interfaceRequestUriField = hostInterface.GetType().GetField("absoluteRequestUri", BindingFlags.NonPublic | BindingFlags.Instance); interfaceRequestUriField.SetValue(hostInterface, new Uri(fixedUpRequestUri)); var wrapperRequestUriField = hostWrapper.GetType().GetField("absoluteRequestUri", BindingFlags.NonPublic | BindingFlags.Instance); wrapperRequestUriField.SetValue(hostWrapper, new Uri(fixedUpRequestUri)); // Take a shower. }
public Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext) { var publishedPackage = (PublishedPackage)entity; string absoluteUri = HttpContext.Current.Request.Url.AbsoluteUri; string siteRoot = absoluteUri.Substring(0, absoluteUri.IndexOf("/FeedService.svc/Packages")); string relativeUri = string.Format("{0}/Package/Download/{1}/{2}", siteRoot, publishedPackage.Id, publishedPackage.Version); return new Uri(relativeUri); }
/// <summary>Initalizes a new <see cref="ProcessRequestArgs"/> instance.</summary> /// <param name="requestUri">The uri for this request.</param> /// <param name="isBatchOperation">True if this request is a operation specified within a batch request, otherwise false.</param> /// <param name="operationContext">Context about the current operation being processed.</param> internal ProcessRequestArgs(Uri requestUri, bool isBatchOperation, DataServiceOperationContext operationContext) { System.Diagnostics.Debug.Assert(requestUri != null, "requestUri != null"); this.requestUri = requestUri; this.isBatchOperation = isBatchOperation; this.OperationContext = operationContext; }
/// <summary>Initalizes a new <see cref="ProcessRequestArgs"/> instance.</summary> /// <param name="requestUri">The uri for this request.</param> /// <param name="isBatchOperation">True if this request is a operation specified within a batch request, otherwise false.</param> /// <param name="operationContext">Context about the current operation being processed.</param> internal ProcessRequestArgs(Uri requestUri, bool isBatchOperation, DataServiceOperationContext operationContext) { System.Diagnostics.Debug.Assert(requestUri != null, "requestUri != null"); this.requestUri = requestUri; this.isBatchOperation = isBatchOperation; this.OperationContext = operationContext; }
public override Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext) { var package = (DataServicePackage)entity; var vpath = GetPackageDownloadPath(package); return new Uri(operationContext.AbsoluteRequestUri, vpath); }
private void InitializeVersion(DataServiceOperationContext operationContext) { if (this.requestVersion == null) { this.requestVersion = operationContext.Host.RequestVersion; } if (this.requestMaxVersion == null) { this.requestMaxVersion = operationContext.Host.RequestMaxVersion; } }
public Stream GetReadStream(object entity, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { if(checkETagForEquality != null) { throw new DataServiceException(400, "This sample service does not support the ETag header for a media resource."); } var imageSource = entity as IImageSource; if(imageSource == null) { throw new DataServiceException(500, "Internal Server Error."); } var image = imageSource.Image; return new MemoryStream(image); }
public string ResolveType(string entitySetName, DataServiceOperationContext operationContext) { // Only be handle ProductCatalog types. if (entitySetName == "ProductCatalog") { return "AdventureWorks_ODataService.ProductCatalog"; } else { // This will raise an DataServiceException. return null; } }
public static void CorrelateWithClientRequestId(DataServiceOperationContext context) { Guid guid; string str = context.RequestHeaders.Get("client-request-id"); if (!string.IsNullOrWhiteSpace(str) && Guid.TryParse(str, out guid)) { TraceHelper.Current.CorrelateWithActivity(guid); if (TraceHelper.IsTestHookEnabled) { TraceHelper.TestHookClientRequestGuid = guid; } } }
/// <summary> /// Returns the default stream that is associated with an entity that has a binary property. /// </summary> /// <param name="entity">The entity for which the descriptor object should be returned.</param> /// <param name="etag">The eTag value sent as part of the HTTP request that is sent to the data service.</param> /// <param name="checkETagForEquality">A nullable System.Boolean value that determines the type of eTag that is used.</param> /// <param name="operationContext">The System.Data.Services.DataServiceOperationContext instance that processes the request.</param> /// <returns>The data System.IO.Stream that contains the binary property data of the entity.</returns> public virtual Stream GetReadStream(object entity, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { var streameable = entity as IStreamEntity; if (streameable == null) return null; using (var client = new WebClient()) { var bytes = client.DownloadData(streameable.GetUrlForStreaming()); return new MemoryStream(bytes); } }
public override Stream GetReadStream(object entity, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { var streameable = entity as IStreamEntity; if (streameable == null) { return null; } using (var client = new WebClient { Credentials = this.credentials }) { var bytes = client.DownloadData(streameable.GetUrlForStreaming()); return new MemoryStream(bytes); } }
public IEnumerable<OperationWrapper> GetServiceActions(DataServiceOperationContext operationContext) { if (this.TryLoadActionProvider()) { IEnumerable<ServiceAction> serviceActions = this.actionProvider.GetServiceActions(operationContext); if (serviceActions != null) { foreach (ServiceAction iteratorVariable1 in serviceActions) { OperationWrapper iteratorVariable2 = this.dataService.Provider.ValidateOperation(iteratorVariable1); if (iteratorVariable2 != null) { yield return iteratorVariable2; } } } } }
//Named Resource using .NET Framework 4.5 public Stream GetReadStream(object entity, ResourceProperty resourceProperty, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { vProductCatalog image = entity as vProductCatalog; if (checkETagForEquality != null) { // This stream provider implementation does not support // ETag headers for media resources. This means that we do not track // concurrency for a media resource and last-in wins on updates. throw new DataServiceException(400, "This sample service does not support the ETag header for a media resource."); } if (image == null) { throw new DataServiceException(500, "Internal Server Error."); } // Return a stream that contains the requested ThumbnailPhoto or LargePhoto return ProductPhoto(image.ProductID, resourceProperty.Name); }
public IEnumerable<OperationWrapper> GetServiceActionsByBindingParameterType(DataServiceOperationContext operationContext, ResourceType bindingParameterType) { Func<ServiceAction, OperationWrapper> selector = null; IEnumerable<OperationWrapper> emptyServiceOperationWrapperEnumeration = EmptyServiceOperationWrapperEnumeration; HashSet<string> existingActionNames = new HashSet<string>(EqualityComparer<string>.Default); do { IEnumerable<OperationWrapper> enumerable2; if (!this.ServiceActionByResourceTypeCache.TryGetValue(bindingParameterType, out enumerable2)) { if (this.TryLoadActionProvider()) { IEnumerable<ServiceAction> serviceActionsByBindingParameterType = this.actionProvider.GetServiceActionsByBindingParameterType(operationContext, bindingParameterType); if ((serviceActionsByBindingParameterType != null) && serviceActionsByBindingParameterType.Any<ServiceAction>()) { if (selector == null) { selector = serviceAction => this.ValidateCanAdvertiseServiceAction(bindingParameterType, serviceAction, existingActionNames); } enumerable2 = (from serviceOperationWrapper in serviceActionsByBindingParameterType.Select<ServiceAction, OperationWrapper>(selector) where serviceOperationWrapper != null select serviceOperationWrapper).ToArray<OperationWrapper>(); } } if (enumerable2 == null) { enumerable2 = EmptyServiceOperationWrapperEnumeration; } this.ServiceActionByResourceTypeCache[bindingParameterType] = enumerable2; } if (enumerable2.Any<OperationWrapper>()) { emptyServiceOperationWrapperEnumeration = emptyServiceOperationWrapperEnumeration.Concat<OperationWrapper>(enumerable2); } bindingParameterType = bindingParameterType.BaseType; } while (bindingParameterType != null); return emptyServiceOperationWrapperEnumeration; }
public string GetStreamContentType(object entity, DataServiceOperationContext operationContext) { // Get the PhotoInfo entity instance. Attachment attach = entity as Attachment; if (attach == null) { throw new DataServiceException(500, "Internal Server Error."); } switch ((AttachmentFormat) attach.Format) { case AttachmentFormat.Bmp: return "image/x-ms-bmp"; case AttachmentFormat.Jpg: return "image/jpeg"; case AttachmentFormat.Png: return "image/x-png"; case AttachmentFormat.Pdf: return "application/pdf"; default: return "application/x-unknown"; } }
internal MetadataProviderEdmModel(DataServiceProviderWrapper provider, DataServiceOperationContext operationContext, DataServiceStreamProviderWrapper streamProviderWrapper) { this.metadataProvider = provider; this.operationContext = operationContext; this.streamProviderWrapper = streamProviderWrapper; this.schemaTypeCache = new Dictionary<string, IEdmSchemaType>(StringComparer.Ordinal); this.resourceTypesPerNamespaceCache = new Dictionary<string, HashSet<ResourceType>>(StringComparer.Ordinal); this.entityContainerCache = new Dictionary<string, MetadataProviderEdmEntityContainer>(StringComparer.Ordinal); this.primitiveOrComplexCollectionTypeCache = new Dictionary<ResourceType, IEdmCollectionType>(EqualityComparer<ResourceType>.Default); this.entityPrimitiveOrComplexCollectionTypeCache = new Dictionary<ResourceType, IEdmCollectionType>(EqualityComparer<ResourceType>.Default); this.derivedTypeMappings = new Dictionary<IEdmStructuredType, List<IEdmStructuredType>>(EqualityComparer<IEdmStructuredType>.Default); this.associationSetByKeyCache = new Dictionary<string, string>(StringComparer.Ordinal); Version version = this.metadataProvider.Configuration.DataServiceBehavior.MaxProtocolVersion.ToVersion(); this.SetDataServiceVersion(version); Version version2 = null; if (!MetadataProviderUtils.DataServiceEdmVersionMap.TryGetValue(version, out version2)) { this.SetEdmVersion(Microsoft.Data.Edm.Library.EdmConstants.EdmVersionLatest); } else { this.SetEdmVersion(version2); } }
/// <summary> /// Returns the URI that is used to request the data stream that is associated with the binary property of an entity. /// </summary> /// <param name="entity">The entity that has the associated binary data stream.</param> /// <param name="operationContext">The System.Data.Services.DataServiceOperationContext /// instance used by the data service to process the request.</param> /// <returns>A System.Uri value that is used to request the binary data stream.</returns> public virtual Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext) { var streameable = entity as IStreamEntity; return streameable != null ? streameable.GetUrlForStreaming() : null; }
internal void AssertDebugStateDuringRequestProcessing(DataServiceOperationContext operationContext) { }
/// <summary> /// This method is invoked by the data services framework to obtain metadata about the stream associated with the specified entity. /// </summary> /// <param name="entity">The entity for which the descriptor object should be returned.</param> /// <param name="operationContext">The System.Data.Services.DataServiceOperationContext instance that processes the request.</param> public virtual void DeleteStream(object entity, DataServiceOperationContext operationContext) { throw new NotImplementedException(); }
/// <summary> /// Returns a namespace-qualified type name that represents the type that the data service /// runtime must create for the Media Link Entry that is associated with the data stream /// for the Media Resource that is being inserted. /// </summary> /// <param name="entitySetName">Fully-qualified entity set name.</param> /// <param name="operationContext">The System.Data.Services.DataServiceOperationContext /// instance that is used by the data service to process the request.</param> /// <returns>A namespace-qualified type name.</returns> public virtual string ResolveType(string entitySetName, DataServiceOperationContext operationContext) { throw new NotImplementedException(); }
/// <summary> /// Returns the stream that the data service uses to write the contents of a binary property that is associated with an entity. /// </summary> /// <param name="entity">The entity that has the associated binary stream.</param> /// <param name="etag">The eTag value that is sent as part of the HTTP request that is sent to the data service.</param> /// <param name="checkETagForEquality">A nullable System.Boolean value that determines the type of eTag is used.</param> /// <param name="operationContext">The System.Data.Services.DataServiceOperationContext /// instance that is used by the data service to process the request.</param> /// <returns>A valid System.Stream the data service uses to write the contents of a /// binary property that is associated with the entity.</returns> public virtual Stream GetWriteStream(object entity, string etag, bool? checkETagForEquality, DataServiceOperationContext operationContext) { throw new NotImplementedException(); }
internal static Uri GetResultUri(DataServiceOperationContext operationContext) { UriBuilder builder = new UriBuilder(operationContext.AbsoluteRequestUri) { Query = null }; if (builder.Path.EndsWith("()", StringComparison.Ordinal)) { builder.Path = builder.Path.Substring(0, builder.Path.Length - 2); } return builder.Uri; }
public virtual string GetStreamContentType(object entity, DataServiceOperationContext operationContext) { return ContentType; }
/// <summary> /// Constructs a new instance of DataServicePipelineEventArgs object /// </summary> /// <param name="operationContext">Context for the operation which the current event is fired for.</param> internal DataServiceProcessingPipelineEventArgs(DataServiceOperationContext operationContext) { Debug.Assert(operationContext != null, "operationContext != null"); this.operationContext = operationContext; }
internal static Uri GetAbsoluteUriFromReference(string reference, DataServiceOperationContext operationContext) { return GetAbsoluteUriFromReference(reference, operationContext.AbsoluteServiceUri, operationContext.Host.RequestVersion); }
internal void AssertDebugStateDuringRequestProcessing(DataServiceOperationContext operationContext) { }
public virtual string GetStreamETag(object entity, DataServiceOperationContext operationContext) { return ETag; }
internal DataServiceProcessingPipelineEventArgs(DataServiceOperationContext operationContext) { this.operationContext = operationContext; }
/// <summary> /// Returns the eTag of the data stream that is associated with the specified entity. /// </summary> /// <param name="entity">The entity that has the associated binary data stream.</param> /// <param name="operationContext">The System.Data.Services.DataServiceOperationContext /// instance used by the data service to process the request.</param> /// <returns>ETag of the stream associated with the entity.</returns> public virtual string GetStreamETag(object entity, DataServiceOperationContext operationContext) { var streameable = entity as IStreamEntity; return streameable != null ? streameable.GetStreamETag() : null; }
internal static void UpdateMetadataVersion(DataServiceProviderWrapper provider, DataServiceOperationContext operationContext, out Version metadataVersion, out MetadataEdmSchemaVersion edmSchemaVersion) { metadataVersion = Version1Dot0; edmSchemaVersion = MetadataEdmSchemaVersion.Version1Dot0; if (!provider.IsV1Provider) { edmSchemaVersion = WebUtil.RaiseMetadataEdmSchemaVersion(edmSchemaVersion, MetadataEdmSchemaVersion.Version1Dot1); } foreach (ResourceType type in provider.GetVisibleTypes(operationContext)) { UpdateMetadataVersionForResourceType(type, ref metadataVersion, ref edmSchemaVersion); } if (provider.HasAnnotations(operationContext)) { edmSchemaVersion = WebUtil.RaiseMetadataEdmSchemaVersion(edmSchemaVersion, MetadataEdmSchemaVersion.Version3Dot0); } foreach (OperationWrapper wrapper in provider.GetVisibleOperations(operationContext)) { if (wrapper.Kind == OperationKind.Action) { edmSchemaVersion = WebUtil.RaiseMetadataEdmSchemaVersion(edmSchemaVersion, MetadataEdmSchemaVersion.Version3Dot0); metadataVersion = WebUtil.RaiseVersion(metadataVersion, Version3Dot0); break; } if (((wrapper.ResultKind == ServiceOperationResultKind.Void) || (wrapper.ResultKind == ServiceOperationResultKind.QueryWithSingleResult)) || (((wrapper.ResultKind == ServiceOperationResultKind.DirectValue) || (wrapper.ResultType.ResourceTypeKind == ResourceTypeKind.ComplexType)) || (wrapper.ResultType.ResourceTypeKind == ResourceTypeKind.Primitive))) { edmSchemaVersion = WebUtil.RaiseMetadataEdmSchemaVersion(edmSchemaVersion, MetadataEdmSchemaVersion.Version1Dot1); break; } } }
public virtual Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext) { throw new NotSupportedException(); }
internal ProcessRequestArgs(Uri requestUri, bool isBatchOperation, DataServiceOperationContext operationContext) { this.requestUri = requestUri; this.isBatchOperation = isBatchOperation; this.OperationContext = operationContext; }