/// <summary>
/// Returns the ETag of the stream
/// </summary>
/// <param name="entity">Entity with the stream</param>
/// <param name="operationContext">Gives the operation context</param>
/// <returns>Returns the Stream ETag</returns>
public virtual string GetStreamETag(object entity, DataServiceOperationContext operationContext)
{
ExceptionUtilities.CheckArgumentNotNull(entity, "entity");
this.CheckOperationContext(operationContext);
return(this.GetStreamETagInternal(entity, null));
}
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.");
}
PhotoInfo image = entity as PhotoInfo;
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 = imageFilePath + "image" + image.PhotoId;
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));
}
internal void DeleteStream(object entity, DataServiceOperationContext operationContext)
{
InvokeApiCallAndValidateHeaders <bool>("IDataServiceStreamProvider.DeleteStream", delegate {
this.LoadAndValidateStreamProvider().DeleteStream(entity, operationContext);
return(true);
}, operationContext);
}
/// <summary>
/// Initializes a new instance of the TestDataServiceInvokable class
/// </summary>
/// <param name="dataServiceInstance">Data Service Instance</param>
/// <param name="dataServiceOperationContext">Data Service Operation Context</param>
/// <param name="serviceAction">Service Action</param>
/// <param name="parameters">Parameters to use</param>
public TestDataServiceInvokable(object dataServiceInstance, DataServiceOperationContext dataServiceOperationContext, ServiceAction serviceAction, object[] parameters)
{
this.dataServiceOperationContext = dataServiceOperationContext;
this.dataServiceInstance = dataServiceInstance;
this.serviceAction = serviceAction;
this.parameters = parameters;
}
/// <summary>
/// Invokes an expression that represents the full request.
/// </summary>
/// <param name="requestExpression"> An expression that includes calls to
/// one or more MethodInfo or one or more calls to
/// IDataServiceUpdateProvider2.InvokeAction(..) or
/// IDataServiceQueryProvider2.InvokeFunction(..)</param>
/// <param name="operationContext"> Current context. </param>
/// <returns>The result of the invoked expression.</returns>
public object Execute(System.Linq.Expressions.Expression requestExpression, DataServiceOperationContext operationContext)
{
Debug.Assert(requestExpression != null, "requestExpression != null");
Debug.Assert(operationContext != null, "operationContext != null");
return ExpressionEvaluator.Evaluate(requestExpression);
}
public string GetStreamETag(object entity, DataServiceOperationContext operationContext)
{
// This sample provider does not support the eTag header with media resources.
// This means that we do not track concurrency for a media resource
// and last-in wins on updates.
return(null);
}
public IEnumerable <OperationWrapper> GetVisibleOperations(DataServiceOperationContext operationContext)
{
HashSet <string> names = new HashSet <string>(EqualityComparer <string> .Default);
IEnumerable <ServiceOperation> serviceOperations = this.metadataProvider.ServiceOperations;
if (serviceOperations != null)
{
foreach (ServiceOperation iteratorVariable2 in serviceOperations)
{
AddUniqueNameToSet((iteratorVariable2 != null) ? iteratorVariable2.Name : null, names, System.Data.Services.Strings.DataServiceProviderWrapper_MultipleServiceOperationsWithSameName(iteratorVariable2.Name));
OperationWrapper iteratorVariable3 = this.ValidateOperation(iteratorVariable2);
if (iteratorVariable3 != null)
{
yield return(iteratorVariable3);
}
}
}
IEnumerator <OperationWrapper> enumerator = this.dataService.ActionProvider.GetServiceActions(operationContext).GetEnumerator();
Func <ResourceSetWrapper, bool> predicate = null;
OperationWrapper serviceAction;
while (enumerator.MoveNext())
{
serviceAction = enumerator.Current;
AddUniqueNameToSet(serviceAction.Name, names, System.Data.Services.Strings.DataServiceProviderWrapper_MultipleServiceOperationsWithSameName(serviceAction.Name));
List <ResourceSetWrapper> source = new List <ResourceSetWrapper>();
if (serviceAction.BindingParameter != null)
{
ResourceType subType = serviceAction.BindingParameter.ParameterType;
if (subType.ResourceTypeKind == ResourceTypeKind.EntityCollection)
{
subType = ((EntityCollectionResourceType)subType).ItemType;
}
foreach (ResourceSetWrapper wrapper in this.GetResourceSets())
{
if (wrapper.ResourceType.IsAssignableFrom(subType))
{
source.Add(wrapper);
}
}
if (source.Count <ResourceSetWrapper>() == 0)
{
throw new InvalidOperationException(System.Data.Services.Strings.DataServiceProviderWrapper_ActionHasNoBindableSet(serviceAction.Name, serviceAction.BindingParameter.ParameterType.FullName));
}
}
if (serviceAction.ResultSetPathExpression != null)
{
if (predicate == null)
{
predicate = set => serviceAction.ResultSetPathExpression.GetTargetSet(this, set) != null;
}
if (!source.Any <ResourceSetWrapper>(predicate))
{
throw new InvalidOperationException(System.Data.Services.Strings.DataServiceProviderWrapper_ActionHasNoVisibleSetReachableFromPathExpression(serviceAction.Name, serviceAction.ResultSetPathExpression.PathExpression));
}
}
yield return(serviceAction);
}
}
public string ResolveType(string entitySetName, DataServiceOperationContext operationContext)
{
CheckStringArgumentNull(entitySetName, "entitySetName");
CheckArgumentNull(operationContext, "operationContext");
this.ThrowIfDisposed();
return(this.ResolveTypeInternal(entitySetName, operationContext));
}
/// <summary>
/// Returns the resource type of the media link entry associated with the the media resource being created
/// </summary>
/// <param name="entitySetName">The name of the entity set</param>
/// <param name="operationContext">The data service operation context</param>
/// <returns>Returns the type of the media link entry</returns>
public virtual string ResolveType(string entitySetName, DataServiceOperationContext operationContext)
{
ExceptionUtilities.CheckArgumentNotNull(entitySetName, "entitySetName");
this.CheckOperationContext(operationContext);
var entityTypeHint = operationContext.RequestHeaders[EntityTypeHintHeaderName];
return(entityTypeHint != null?Uri.UnescapeDataString(entityTypeHint) : null);
}
public Stream GetWriteStream(
object entity,
string etag,
bool?checkETagForEquality,
DataServiceOperationContext operationContext)
{
throw new NotSupportedException();
}
/// <summary>
/// Deletes a streams associated with an entity
/// </summary>
/// <param name="entity">Entity to delete streams from</param>
/// <param name="operationContext">Gives the operation context</param>
public virtual void DeleteStream(object entity, DataServiceOperationContext operationContext)
{
ExceptionUtilities.CheckArgumentNotNull(entity, "entity");
this.CheckOperationContext(operationContext);
// this will remove named streams as well
BlobsStorage.Remove(entity);
}
public IEnumerable <ServiceAction> GetServiceActions(DataServiceOperationContext operationContext)
{
if (this.GetServiceActionsCallback != null)
{
return(this.GetServiceActionsCallback(operationContext));
}
throw new NotImplementedException();
}
public void GetQueryStringItemAsksHost()
{
var host = new DataServiceHost2Simulator();
host.SetQueryStringItem("some-key", "test-value");
DataServiceOperationContext context = new DataServiceOperationContext(host);
context.GetQueryStringValue("some-key").Should().Be("test-value");
}
/// <summary>
/// Builds up an instance oz <see cref="IDataServiceInvokable"/> for the given <paramref name="serviceAction"/> with the provided <paramref name="parameterTokens"/>.
/// </summary>
/// <param name="operationContext">The data service operation context instance.</param>
/// <param name="serviceAction">The service action to invoke.</param>
/// <param name="parameterTokens">The parameter tokens required to invoke the service action.</param>
/// <returns>An instance of <see cref="IDataServiceInvokable"/> to invoke the action with.</returns>
public IDataServiceInvokable CreateInvokable(DataServiceOperationContext operationContext, ServiceAction serviceAction, object[] parameterTokens)
{
if (DataServiceOverrides.ActionProvider.CreateInvokableFunc != null)
{
return(DataServiceOverrides.ActionProvider.CreateInvokableFunc(operationContext, serviceAction, parameterTokens));
}
return(new TestDataServiceInvokable(this.dataServiceInstance, operationContext, serviceAction, parameterTokens));
}
/// <summary>
/// Gets a collection of actions having <paramref name="bindingParameterType"/> as the binding parameter type.
/// </summary>
/// <param name="operationContext">The data service operation context instance.</param>
/// <param name="bindingParameterType">Instance of the binding parameter resource type (<see cref="ResourceType"/>) in question.</param>
/// <returns>A list of actions having <paramref name="bindingParameterType"/> as the binding parameter type.</returns>
public IEnumerable <ServiceAction> GetServiceActionsByBindingParameterType(DataServiceOperationContext operationContext, ResourceType bindingParameterType)
{
if (DataServiceOverrides.ActionProvider.GetServiceActionsByBindingParameterTypeFunc != null)
{
return(DataServiceOverrides.ActionProvider.GetServiceActionsByBindingParameterTypeFunc(operationContext, bindingParameterType));
}
return(this.GetServiceActionsInternal(operationContext).Where(sa => sa.BindingParameter != null && sa.BindingParameter.ParameterType.FullName == bindingParameterType.FullName));
}
/// <summary>
/// Returns all service actions in the provider.
/// </summary>
/// <param name="operationContext">operation Context</param>
/// <returns>An enumeration of all service actions.</returns>
public IEnumerable <ServiceAction> GetServiceActions(DataServiceOperationContext operationContext)
{
if (DataServiceOverrides.ActionProvider.GetServiceActionsFunc != null)
{
return(DataServiceOverrides.ActionProvider.GetServiceActionsFunc(operationContext));
}
return(this.GetServiceActionsInternal(operationContext));
}
public IEnumerable <ServiceAction> GetServiceActionsByBindingParameterType(DataServiceOperationContext operationContext, ResourceType bindingParameterType)
{
if (this.GetByBindingTypeCallback != null)
{
return(this.GetByBindingTypeCallback(operationContext, bindingParameterType));
}
throw new NotImplementedException();
}
private bool FailToResolveSpecificActionOnEntityType(DataServiceOperationContext operationContextFromProduct, ServiceActionResolverArgs resolverArgs, out ServiceAction serviceAction)
{
operationContextFromProduct.Should().BeSameAs(this.operationContext);
resolverArgs.Should().NotBeNull();
resolverArgs.ServiceActionName.Should().Be(this.action.Name);
resolverArgs.BindingType.Should().BeSameAs(this.entityType);
serviceAction = null;
return(false);
}
/// <summary>
/// Determines whether a given <paramref name="serviceAction"/> should be advertised as bindable to the given <paramref name="resourceInstance"/>.
/// </summary>
/// <param name="operationContext">The data service operation context instance.</param>
/// <param name="serviceAction">Service action to be advertised.</param>
/// <param name="resourceInstance">Instance of the resource to which the service action is bound.</param>
/// <param name="resourceInstanceInFeed">true if the resource instance to be serialized is inside a feed; false otherwise. The value true
/// suggests that this method might be called many times during serialization since it will get called once for every resource instance inside
/// the feed. If it is an expensive operation to determine whether to advertise the service action for the <paramref name="resourceInstance"/>,
/// the provider may choose to always advertise in order to optimize for performance.</param>
/// <param name="actionToSerialize">The <see cref="ODataAction"/> to be serialized. The server constructs
/// the version passed into this call, which may be replaced by an implementation of this interface.
/// This should never be set to null unless returning false.</param>
/// <returns>true if the service action should be advertised; false otherwise.</returns>
public override bool AdvertiseServiceAction(DataServiceOperationContext operationContext, ServiceAction serviceAction, object resourceInstance, bool resourceInstanceInFeed, ref ODataAction actionToSerialize)
{
if (SubstituteAdvertiseServiceAction != null)
{
return(SubstituteAdvertiseServiceAction(operationContext, serviceAction, resourceInstance, resourceInstanceInFeed, ref actionToSerialize));
}
return(base.AdvertiseServiceAction(operationContext, serviceAction, resourceInstance, resourceInstanceInFeed, ref actionToSerialize));
}
/// <summary>
/// This method is invoked by the data services framework to retrieve the default stream associated
/// with the Entity Type specified by the <paramref name="entity"/> parameter.
/// Note that we set the response ETag in the host object before we return.
/// </summary>
/// <param name="entity">The stream returned should be the default stream associated with this entity.</param>
/// <param name="operationContext">A reference to the context for the current operation.</param>
/// <returns>A valid stream the data service use to query / read a streamed BLOB which is associated with the <paramref name="entity"/>.</returns>
internal Stream GetReadStream(object entity, DataServiceOperationContext operationContext)
{
Debug.Assert(entity != null, "entity != null");
Debug.Assert(operationContext != null, "operationContext != null");
string etagFromHeader;
bool? checkETagForEquality;
DataServiceStreamProviderWrapper.GetETagFromHeaders(operationContext, out etagFromHeader, out checkETagForEquality);
Debug.Assert(
string.IsNullOrEmpty(etagFromHeader) && !checkETagForEquality.HasValue || !string.IsNullOrEmpty(etagFromHeader) && checkETagForEquality.HasValue,
"etag and checkETagForEquality parameters must both be set or not set at the same time.");
Stream readStream = null;
try
{
readStream = InvokeApiCallAndValidateHeaders("IDataServiceStreamProvider.GetReadStream", () => this.StreamProvider.GetReadStream(entity, etagFromHeader, checkETagForEquality, operationContext), operationContext);
}
catch (DataServiceException e)
{
if (e.StatusCode == (int)System.Net.HttpStatusCode.NotModified)
{
// For status code 304, we MUST set the etag value. Our Error handler will translate
// DataServiceException(304) to a normal response with status code 304 and an empty message-body.
#if DEBUG
WebUtil.WriteETagValueInResponseHeader(null, this.GetStreamETag(entity, operationContext), operationContext.Host);
#else
WebUtil.WriteETagValueInResponseHeader(this.GetStreamETag(entity, operationContext), operationContext.Host);
#endif
}
throw;
}
try
{
if (readStream == null || !readStream.CanRead)
{
throw new InvalidOperationException(Strings.DataService_InvalidStreamFromGetReadStream);
}
// GetStreamETag can throw and we need to catch and dispose the stream.
#if DEBUG
WebUtil.WriteETagValueInResponseHeader(null, this.GetStreamETag(entity, operationContext), operationContext.Host);
#else
WebUtil.WriteETagValueInResponseHeader(this.GetStreamETag(entity, operationContext), operationContext.Host);
#endif
}
catch
{
WebUtil.Dispose(readStream);
throw;
}
return(readStream);
}
internal static string GetContentTypeFromHeaders(DataServiceOperationContext operationContext)
{
if (operationContext != null)
{
return(operationContext.RequestHeaders[HttpRequestHeader.ContentType]);
}
return(null);
}
public ActionInvokable(DataServiceOperationContext operationContext, ServiceAction serviceAction, object site, object[] parameters, IParameterMarshaller marshaller)
{
_serviceAction = serviceAction;
ActionInfo info = serviceAction.CustomState as ActionInfo;
var marshalled = marshaller.Marshall(operationContext, serviceAction, parameters);
info.AssertAvailable(site, marshalled[0], true);
_action = () => CaptureResult(info.ActionMethod.Invoke(site, marshalled));
}
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));
}
public bool TryResolveServiceAction(DataServiceOperationContext operationContext, string serviceActionName, out ServiceAction serviceAction)
{
if (this.TryResolveServiceActionCallback != null)
{
return(this.TryResolveServiceActionCallback(operationContext, serviceActionName, out serviceAction));
}
throw new NotImplementedException();
}
public void ResolveType(string entitySetName, DataServiceOperationContext operationContext)
{
Parent.Add(new APICallLogEntry("IDataServiceStreamProvider.ResolveType",
"entitySetName", (entitySetName == null ? "null" : entitySetName),
"AbsoluteRequestUri", operationContext.AbsoluteRequestUri.ToString(),
"AbsoluteServiceUri", operationContext.AbsoluteServiceUri.ToString(),
"IsBatchRequest", operationContext.IsBatchRequest.ToString(),
"RequestMethod", operationContext.RequestMethod.ToUpperInvariant()));
}
public void GetStreamETag(object entity, DataServiceOperationContext operationContext)
{
Parent.Add(new APICallLogEntry("IDataServiceStreamProvider.GetStreamETag",
"entity", this.Parent.Serialize(entity),
"AbsoluteRequestUri", operationContext.AbsoluteRequestUri.ToString(),
"AbsoluteServiceUri", operationContext.AbsoluteServiceUri.ToString(),
"IsBatchRequest", operationContext.IsBatchRequest.ToString(),
"RequestMethod", operationContext.RequestMethod.ToUpperInvariant()));
}
public override Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext)
{
var package = (V2FeedPackage)entity;
var urlHelper = new UrlHelper(new RequestContext(HttpContext, new RouteData()));
string url = urlHelper.PackageDownload(FeedVersion, package.Id, package.Version);
return(new Uri(url, UriKind.Absolute));
}
public Uri GetReadStreamUri(object entity, DataServiceOperationContext operationContext)
{
var package = (Package)entity;
var rootUrl = Helpers.GetRootUrl();
string downloadUrl = PackageUtility.GetPackageDownloadUrl(package);
return(new Uri(rootUrl + downloadUrl));
}
public bool TryResolveServiceAction(DataServiceOperationContext operationContext, ServiceActionResolverArgs resolverArgs, out ServiceAction serviceAction)
{
if (this.callback != null)
{
return(this.callback(operationContext, resolverArgs, out serviceAction));
}
throw new NotImplementedException();
}
/// <summary>
/// Gets the ETag, ReadStreamUri and ContentType of the stream
/// </summary>
/// <param name="entity">MLE instance</param>
/// <param name="operationContext">context of the current operation</param>
/// <param name="mediaLinkEntryUri">Uri to the MLE</param>
/// <param name="etag">returns the etag for the stream</param>
/// <param name="readStreamUri">returns the read stream uri</param>
/// <param name="contentType">returns the content type of the stream</param>
internal void GetStreamDescription(object entity, DataServiceOperationContext operationContext, string mediaLinkEntryUri, out string etag, out Uri readStreamUri, out string contentType)
{
Debug.Assert(entity != null, "entity != null");
Debug.Assert(operationContext != null, "operationContext != null");
// Call order is part of our contract, do not change it.
etag = this.GetStreamETag(entity, operationContext);
readStreamUri = this.GetReadStreamUri(entity, operationContext, mediaLinkEntryUri);
contentType = this.GetStreamContentType(entity, operationContext);
}
public void DeleteStream(object entity, DataServiceOperationContext operationContext)
{
this.ThrowIfDisposed();
CheckArgumentNull(entity, "entity");
CheckArgumentNull(operationContext, "operationContext");
ValidateEntity(entity);
this.DeleteStreams(entity);
}
string IDataServiceStreamProvider.GetStreamContentType(object entity, DataServiceOperationContext host)
{
if (entity is InternalPicture)
{
InternalPicture pict = entity as InternalPicture;
this.LoadFileStorageIfItsNotLoaded(pict, "PT.FK_FileStorage_InternalPictures1", "FileStorage");
return pict.FileStorage.ContentType;
}
else if (entity is ExternalPicture)
{
ExternalPicture pict = entity as ExternalPicture;
return string.IsNullOrEmpty(pict.ContentType) ? "text/plain" : pict.ContentType;
}
else
{
throw new NotSupportedException("Unexpected entity type!");
}
}
string IDataServiceStreamProvider.GetStreamETag(object entity, DataServiceOperationContext host)
{
if (entity is ExternalPicture)
{
ExternalPicture pict = entity as ExternalPicture;
return pict.BlobETag;
}
if (entity is InternalPicture)
{
InternalPicture pict = entity as InternalPicture;
// ETag value is timestamp of the storage file
if (this.GetEntityState(pict) != EntityState.Added)
{
this.LoadFileStorageIfItsNotLoaded(pict, "PT.FK_FileStorage_InternalPictures1", "FileStorage");
if (pict.FileStorage == null)
return null;
var creationTime = System.Data.Test.Astoria.FullTrust.TrustedMethods.GetFileCreationTime(DataPath(pict.FileStorage.Location));
return string.Concat("\"", creationTime.ToString("dd MMMM yyyy hh:mm:ss.ffffff", System.Globalization.DateTimeFormatInfo.InvariantInfo), "\"");
}
}
return null;
}
Stream IDataServiceStreamProvider.GetWriteStream(object entity, string Etag, bool? checkETagForEquality, DataServiceOperationContext host)
{
//Debug.Assert(entity is InternalPicture, "Unexpected entity type!");
InternalPicture pict = entity as InternalPicture;
if (pict != null)
{
string filename = host.RequestHeaders.AllKeys.Contains("Slug") ? host.RequestHeaders["Slug"] : string.Format("{0}.txt", Guid.NewGuid());
if (filename.Contains(@"FAIL"))
throw new InvalidOperationException("'FAIL' in Slug :: Test hook for exception!");
string contentType = host.RequestHeaders.AllKeys.Contains("Content-Type") ? host.RequestHeaders["Content-Type"] : null;
if (this.GetEntityState(pict) != EntityState.Added)
{
this.LoadFileStorageIfItsNotLoaded(pict, "PT.FK_FileStorage_InternalPictures1", "FileStorage");
if (pict.FileStorage != null) {
if (checkETagForEquality != null)
{
// the value of checkETagForEquality should be "True" (if-match header). This code does not understand "False" value (if-none-match header).
if (!(bool)checkETagForEquality)
throw new NotSupportedException("The service does not support if-none-match header !");
// if etag does not match, return 412 -> Precondition failed
// ETag value is timestamp of the storage file
var creationTime = System.Data.Test.Astoria.FullTrust.TrustedMethods.GetFileCreationTime(DataPath(pict.FileStorage.Location));
string fileCreationTimeStamp = string.Concat("\"", creationTime.ToString("dd MMMM yyyy hh:mm:ss.ffffff", System.Globalization.DateTimeFormatInfo.InvariantInfo), "\"");
if (fileCreationTimeStamp != Etag)
{
throw new DataServiceException(412, string.Format("Etag values does not match, expected: {0}, actual: {1}", Etag, fileCreationTimeStamp));
}
}
pict.FileStorage.ContentType = contentType;
pict.FileStorage.Location = filename;
}
else
{
// else - trouble, incosistent data - 500(internal error)
throw new DataServiceException("Inconsistent data found, giving up!");
}
}
else
{
FileStorage fs = new FileStorage { ContentType = contentType, Location = filename, Picture = pict };
entityContext.AddObject("FileStorage", fs);
}
return new System.Data.Test.Astoria.FullTrust.TrustedFileStream(DataPath(filename), FileMode.Create, FileAccess.Write, FileShare.Write);
}
else
{
throw new NotSupportedException("Unexpected entity type!");
}
}
Uri IDataServiceStreamProvider.GetReadStreamUri(object entity, DataServiceOperationContext host)
{
Uri uri = null;
if (entity is ExternalPicture)
{
ExternalPicture pict = entity as ExternalPicture;
if (!string.IsNullOrEmpty(pict.URL))
{
string url = pict.URL;
if (url.Contains("${"))
{
url = replaceParams(url, GetParamsTable(host));
}
uri = new Uri(url, UriKind.RelativeOrAbsolute);
}
}
return uri;
}
void IDataServiceStreamProvider.DeleteStream(object entity, DataServiceOperationContext host)
{
//Debug.Assert(entity is InternalPicture || entity is ExternalPicture, "Unexpected entity type!");
if (entity is InternalPicture)
{
InternalPicture pict = entity as InternalPicture;
FileStorage fs = pict.FileStorage ?? entityContext.FileStorage.FirstOrDefault(f => f.Picture.Id == pict.Id);
if (fs != null)
{
System.Data.Test.Astoria.FullTrust.TrustedMethods.DeleteFileIfExists(DataPath(fs.Location));
entityContext.DeleteObject(fs);
}
}
}
private IDictionary<string, string> GetParamsTable( DataServiceOperationContext host)
{
Dictionary<string, string> dict = new Dictionary<string, string>();
string absServicePath = host.AbsoluteServiceUri.ToString().TrimEnd(new char[] { ' ', '/' });
string absServiceFolder = absServicePath.Substring(0, absServicePath.LastIndexOf('/') + 1);
dict.Add("${AbsServicePath}", absServicePath);
dict.Add("${AbsServiceFolder}", absServiceFolder);
return dict;
}
Stream IDataServiceStreamProvider.GetReadStream(object entity, string Etag, bool? checkETagForEquality, DataServiceOperationContext host)
{
//Debug.Assert(entity is InternalPicture || entity is ExternalPicture, "Unexpected entity type!");
if (entity is InternalPicture)
{
InternalPicture pict = entity as InternalPicture;
this.LoadFileStorageIfItsNotLoaded(pict, "PT.FK_FileStorage_InternalPictures1", "FileStorage");
if (pict.FileStorage.ContentDisposition != null) host.ResponseHeaders.Add("Content-Disposition", pict.FileStorage.ContentDisposition);
if (host.RequestHeaders.AllKeys.Contains("B4C-Sleep"))
{
string[] slData = host.RequestHeaders["B4C-Sleep"].Split(',', ';', ' ');
int lockId = Int32.Parse(slData[0]);
int buffSize = Int32.Parse(slData[1]);
return new BlockedFileStream(DataPath(pict.FileStorage.Location), FileMode.Open, FileAccess.Read, FileShare.Read, buffSize, lockId);
}
return new System.Data.Test.Astoria.FullTrust.TrustedFileStream(DataPath(pict.FileStorage.Location), FileMode.Open, FileAccess.Read, FileShare.Read);
}
else if (entity is ExternalPicture)
{
return new MemoryStream(Encoding.UTF8.GetBytes("This is a replacement for external entity link."), false);
}
else
{
throw new NotSupportedException("Unexpected entity type!");
}
}
string IDataServiceStreamProvider.ResolveType(string entitySetName, DataServiceOperationContext host)
{
return typeof(InternalPicture).FullName;
}
