internal static void Translate(DataServiceContext context, bool addTrailingParens, Expression e, out Uri uri, out Version version) { var writer = new UriWriter(context); writer.leafResourceSet = addTrailingParens ? (e as ResourceSetExpression) : null; writer.Visit(e); uri = Util.CreateUri(context.BaseUriWithSlash, Util.CreateUri(writer.uriBuilder.ToString(), UriKind.Relative)); version = writer.uriVersion; }
protected Uri CreateRequestRelativeUri(LinkDescriptor binding) { if (binding.IsSourcePropertyCollection && (EntityStates.Added != binding.State)) { EntityDescriptor entityDescriptor = this.RequestInfo.EntityTracker.GetEntityDescriptor(binding.Target); Uri uri = DataServiceContext.GenerateEditLinkRelativeUri(binding.SourceProperty, entityDescriptor.Entity, this.RequestInfo.MaxProtocolVersion); return(Util.CreateUri("$links" + '/' + CommonUtil.UriToString(uri), UriKind.Relative)); } return(Util.CreateUri("$links" + '/' + binding.SourceProperty, UriKind.Relative)); }
internal static Uri ValidateLocationHeader(string location) { Uri uri = Util.CreateUri(location, UriKind.RelativeOrAbsolute); if (!uri.IsAbsoluteUri) { throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_LocationHeaderExpectsAbsoluteUri); } return(uri); }
internal static void Translate(DataServiceContext context, bool addTrailingParens, Expression e, out Uri uri, out Version version) { UriWriter writer = new UriWriter(context) { leafResourceSet = addTrailingParens ? (e as ResourceSetExpression) : null }; writer.Visit(e); uri = Util.CreateUri(writer.uriBuilder.ToString(), UriKind.Absolute); version = writer.uriVersion; }
private Uri ConvertHRefAttributeValueIntoURI(string href) { Uri uri = Util.CreateUri(href, UriKind.RelativeOrAbsolute); if (!uri.IsAbsoluteUri && !String.IsNullOrEmpty(this.reader.BaseURI)) { Uri baseUri = Util.CreateUri(this.reader.BaseURI, UriKind.RelativeOrAbsolute); uri = new Uri(baseUri, uri); } return(uri); }
internal Uri GetEntitySetUri(string entitySetName) { Uri entitySetUriFromResolver = this.GetEntitySetUriFromResolver(entitySetName); if (entitySetUriFromResolver != null) { return(Util.ForceNonSlashTerminatedUri(entitySetUriFromResolver)); } if (this.baseUriWithSlash == null) { throw Error.InvalidOperation(Strings.Context_ResolveEntitySetOrBaseUriRequired(entitySetName)); } return(Util.CreateUri(this.baseUriWithSlash, new Uri(entitySetName, UriKind.Relative))); }
protected Uri CreateRequestUri(EntityDescriptor sourceResource, LinkDescriptor binding) { Uri uri; LinkInfo linkInfo = null; if (sourceResource.TryGetLinkInfo(binding.SourceProperty, out linkInfo) && ((uri = linkInfo.AssociationLink) != null)) { if (binding.IsSourcePropertyCollection && (EntityStates.Deleted == binding.State)) { EntityDescriptor entityDescriptor = this.RequestInfo.EntityTracker.GetEntityDescriptor(binding.Target); uri = DataServiceContext.AppendKeysToUri(uri.AbsoluteUri, entityDescriptor.Entity, UriKind.Absolute, this.RequestInfo.MaxProtocolVersion); } return(uri); } return(Util.CreateUri(sourceResource.GetResourceUri(this.RequestInfo.BaseUriResolver, false), this.CreateRequestRelativeUri(binding))); }
internal Uri GetNavigationLink(UriResolver baseUriResolver, ClientPropertyAnnotation property) { LinkInfo linkInfo = null; Uri navigationLink = null; if (this.TryGetLinkInfo(property.PropertyName, out linkInfo)) { navigationLink = linkInfo.NavigationLink; } if (navigationLink == null) { Uri requestUri = Util.CreateUri(property.PropertyName + (property.IsEntityCollection ? "()" : string.Empty), UriKind.Relative); navigationLink = Util.CreateUri(this.GetResourceUri(baseUriResolver, true), requestUri); } return(navigationLink); }
/// <summary> /// creates a new uri instance which takes into account the base uri of the reader. /// </summary> /// <param name="href">href attribute value.</param> /// <returns>a new instance of uri as refered by the <paramref name="href"/></returns> private Uri ConvertHRefAttributeValueIntoURI(string href) { Uri uri = Util.CreateUri(href, UriKind.RelativeOrAbsolute); if (!uri.IsAbsoluteUri && !String.IsNullOrEmpty(this.reader.BaseURI)) { Uri baseUri = Util.CreateUri(this.reader.BaseURI, UriKind.RelativeOrAbsolute); // The reason why we can't use Util.CreateUri function here, is that the util method // checks for trailing slashes in the baseuri and starting forward slashes in the request uri // and does some tricks which is not consistent with the uri class behaviour. Hence using the // uri class directly here. uri = new Uri(baseUri, uri); } return(uri); }
internal Uri GetResourceUri(UriResolver baseUriResolver, bool queryLink) { LinkInfo info; if (this.parentDescriptor == null) { return(this.GetLink(queryLink)); } if (this.parentDescriptor.Identity == null) { return(Util.CreateUri(Util.CreateUri(baseUriResolver.GetBaseUriWithSlash(), new Uri("$" + this.parentDescriptor.ChangeOrder.ToString(CultureInfo.InvariantCulture), UriKind.Relative)), Util.CreateUri(this.parentProperty, UriKind.Relative))); } if (this.parentDescriptor.TryGetLinkInfo(this.parentProperty, out info) && (info.NavigationLink != null)) { return(info.NavigationLink); } return(Util.CreateUri(this.parentDescriptor.GetLink(queryLink), this.GetLink(queryLink))); }
protected ODataRequestMessageWrapper CreateRequest(LinkDescriptor binding) { if (binding.ContentGeneratedForSave) { return(null); } EntityDescriptor entityDescriptor = this.RequestInfo.EntityTracker.GetEntityDescriptor(binding.Source); EntityDescriptor descriptor2 = (binding.Target != null) ? this.RequestInfo.EntityTracker.GetEntityDescriptor(binding.Target) : null; Uri requestUri = null; if (entityDescriptor.GetLatestIdentity() == null) { if (!this.IsBatch) { binding.ContentGeneratedForSave = true; throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_LinkResourceInsertFailure, entityDescriptor.SaveError); } Uri uri = this.CreateRequestRelativeUri(binding); requestUri = Util.CreateUri("$" + entityDescriptor.ChangeOrder.ToString(CultureInfo.InvariantCulture) + "/" + CommonUtil.UriToString(uri), UriKind.Relative); } else { if ((!this.IsBatch && (descriptor2 != null)) && (descriptor2.GetLatestIdentity() == null)) { binding.ContentGeneratedForSave = true; throw System.Data.Services.Client.Error.InvalidOperation(System.Data.Services.Client.Strings.Context_LinkResourceInsertFailure, descriptor2.SaveError); } requestUri = this.CreateRequestUri(entityDescriptor, binding); } ODataRequestMessageWrapper requestMessage = this.CreateRequestMessage(requestUri, GetLinkHttpMethod(binding)); if (this.IsBatch) { requestMessage.SetHeader("Content-ID", binding.ChangeOrder.ToString(CultureInfo.InvariantCulture)); } if ((EntityStates.Added == binding.State) || ((EntityStates.Modified == binding.State) && (binding.Target != null))) { requestMessage.SetHeader("Content-Type", "application/xml"); } WebUtil.SetOperationVersionHeaders(requestMessage, Util.DataServiceVersion1, this.RequestInfo.MaxProtocolVersionAsVersion); return(requestMessage); }
internal Uri GetResourceUri(Uri baseUriWithSlash, bool queryLink) { if (this.parentDescriptor != null) { if (this.parentDescriptor.Identity == null) { return(Util.CreateUri( Util.CreateUri(baseUriWithSlash, new Uri("$" + this.parentDescriptor.ChangeOrder.ToString(CultureInfo.InvariantCulture), UriKind.Relative)), Util.CreateUri(this.parentProperty, UriKind.Relative))); } else { return(Util.CreateUri(Util.CreateUri(baseUriWithSlash, this.parentDescriptor.GetLink(queryLink)), this.GetLink(queryLink))); } } else { return(Util.CreateUri(baseUriWithSlash, this.GetLink(queryLink))); } }
internal void WriteEntityReferenceLink(LinkDescriptor binding, ODataRequestMessageWrapper requestMessage) { using (ODataMessageWriter writer = CreateMessageWriter(requestMessage, this.requestInfo)) { Uri resourceUri; EntityDescriptor entityDescriptor = this.requestInfo.EntityTracker.GetEntityDescriptor(binding.Target); if (entityDescriptor.GetLatestIdentity() != null) { resourceUri = entityDescriptor.GetResourceUri(this.requestInfo.BaseUriResolver, false); } else { resourceUri = Util.CreateUri("$" + entityDescriptor.ChangeOrder.ToString(CultureInfo.InvariantCulture), UriKind.Relative); } ODataEntityReferenceLink link = new ODataEntityReferenceLink { Url = resourceUri }; writer.WriteEntityReferenceLink(link); } }
private Uri GetLink(bool queryLink) { if (queryLink && (this.SelfLink != null)) { return(this.SelfLink); } Uri latestEditLink = this.GetLatestEditLink(); if (latestEditLink != null) { return(latestEditLink); } if (base.State != EntityStates.Added) { throw new ArgumentNullException(System.Data.Services.Client.Strings.EntityDescriptor_MissingSelfEditLink(this.identity)); } if (this.addToUri != null) { return(this.addToUri); } return(Util.CreateUri(this.parentProperty, UriKind.Relative)); }
private Uri GetLink(bool queryLink) { if (queryLink && this.SelfLink != null) { return(this.SelfLink); } if (this.EditLink != null) { return(this.EditLink); } Debug.Assert(this.State == EntityStates.Added, "the entity must be in added state"); if (!String.IsNullOrEmpty(this.entitySetName)) { return(Util.CreateUri(this.entitySetName, UriKind.Relative)); } else { return(Util.CreateUri(this.parentProperty, UriKind.Relative)); } }
/// <summary>uri to edit the entity</summary> /// <param name="baseUriWithSlash">baseUriWithSlash</param> /// <param name="queryLink">whether to return the query link or edit link</param> /// <returns>absolute uri which can be used to edit the entity</returns> internal Uri GetResourceUri(Uri baseUriWithSlash, bool queryLink) { // If the entity was inserted using the AddRelatedObject API if (this.parentDescriptor != null) { // This is the batch scenario, where the entity might not have been saved yet, and there is another operation // (for e.g. PUT $1/links/BestFriend or something). Hence we need to generate a Uri with the changeorder number. if (this.parentDescriptor.Identity == null) { return(Util.CreateUri( Util.CreateUri(baseUriWithSlash, new Uri("$" + this.parentDescriptor.ChangeOrder.ToString(CultureInfo.InvariantCulture), UriKind.Relative)), Util.CreateUri(this.parentProperty, UriKind.Relative))); } else { return(Util.CreateUri(Util.CreateUri(baseUriWithSlash, this.parentDescriptor.GetLink(queryLink)), this.GetLink(queryLink))); } } else { return(Util.CreateUri(baseUriWithSlash, this.GetLink(queryLink))); } }
private ODataRequestMessageWrapper CreateBatchRequest() { Uri requestUrl = Util.CreateUri(base.RequestInfo.BaseUriResolver.GetBaseUriWithSlash(), Util.CreateUri("$batch", UriKind.Relative)); ODataRequestMessageWrapper requestMessage = new ODataRequestMessageWrapper("POST", requestUrl, base.RequestInfo); WebUtil.SetOperationVersionHeaders(requestMessage, Util.DataServiceVersion1, base.RequestInfo.MaxProtocolVersionAsVersion); return(requestMessage); }
private void ParseCurrentEntry(out AtomEntry targetEntry) { Debug.Assert(this.reader.NodeType == XmlNodeType.Element, "this.reader.NodeType == XmlNodeType.Element"); var callbackResult = this.entryCallback(this.reader); Debug.Assert(callbackResult.Key != null, "callbackResult.Key != null"); this.readers.Push(this.reader); this.reader = callbackResult.Key; this.reader.Read(); Debug.Assert(this.reader.LocalName == "entry", "this.reader.LocalName == 'entry' - otherwise we're not reading the subtree"); bool hasContent = false; targetEntry = new AtomEntry(); targetEntry.DataValues = new List <AtomContentProperty>(); targetEntry.Tag = callbackResult.Value; targetEntry.ETagText = this.reader.GetAttribute(XmlConstants.AtomETagAttributeName, XmlConstants.DataWebMetadataNamespace); while (this.reader.Read()) { if (ShouldIgnoreNode(this.reader)) { continue; } if (this.reader.NodeType == XmlNodeType.Element) { int depth = this.reader.Depth; string elementName = this.reader.LocalName; string namespaceURI = this.reader.NamespaceURI; if (namespaceURI == XmlConstants.AtomNamespace) { if (elementName == XmlConstants.AtomCategoryElementName && targetEntry.TypeName == null) { string text = this.reader.GetAttributeEx(XmlConstants.AtomCategorySchemeAttributeName, XmlConstants.AtomNamespace); if (text == this.typeScheme) { targetEntry.TypeName = this.reader.GetAttributeEx(XmlConstants.AtomCategoryTermAttributeName, XmlConstants.AtomNamespace); } } else if (elementName == XmlConstants.AtomContentElementName) { hasContent = true; this.ParseCurrentContent(targetEntry); } else if (elementName == XmlConstants.AtomIdElementName && targetEntry.Identity == null) { string idText = ReadElementStringForText(this.reader); idText = Util.ReferenceIdentity(idText); Uri idUri = Util.CreateUri(idText, UriKind.RelativeOrAbsolute); if (!idUri.IsAbsoluteUri) { throw Error.InvalidOperation(Strings.Context_TrackingExpectsAbsoluteUri); } targetEntry.Identity = idText; } else if (elementName == XmlConstants.AtomLinkElementName) { this.ParseCurrentLink(targetEntry); } } else if (namespaceURI == XmlConstants.DataWebMetadataNamespace) { if (elementName == XmlConstants.AtomPropertiesElementName) { if (targetEntry.MediaLinkEntry.HasValue && !targetEntry.MediaLinkEntry.Value) { throw Error.InvalidOperation(Strings.Deserialize_ContentPlusPropertiesNotAllowed); } targetEntry.MediaLinkEntry = true; if (!this.reader.IsEmptyElement) { this.ReadCurrentProperties(targetEntry.DataValues); } } } SkipToEndAtDepth(this.reader, depth); } } if (targetEntry.Identity == null) { throw Error.InvalidOperation(Strings.Deserialize_MissingIdElement); } if (!hasContent) { throw Error.BatchStreamContentExpected(BatchStreamState.GetResponse); } this.reader = this.readers.Pop(); }
internal Uri GetEditMediaResourceUri(Uri serviceBaseUri) { return(this.EditStreamUri == null ? null : Util.CreateUri(serviceBaseUri, this.EditStreamUri)); }
internal static object ChangeType(string propertyValue, Type propertyType) { Debug.Assert(null != propertyValue, "should never be passed null"); try { switch ((StorageType)IndexOfStorage(propertyType)) { case StorageType.Boolean: return(XmlConvert.ToBoolean(propertyValue)); case StorageType.Byte: return(XmlConvert.ToByte(propertyValue)); case StorageType.ByteArray: return(Convert.FromBase64String(propertyValue)); case StorageType.Char: return(XmlConvert.ToChar(propertyValue)); case StorageType.CharArray: return(propertyValue.ToCharArray()); case StorageType.DateTime: return(XmlConvert.ToDateTime(propertyValue, XmlDateTimeSerializationMode.RoundtripKind)); case StorageType.DateTimeOffset: return(XmlConvert.ToDateTimeOffset(propertyValue)); case StorageType.Decimal: return(XmlConvert.ToDecimal(propertyValue)); case StorageType.Double: return(XmlConvert.ToDouble(propertyValue)); case StorageType.Guid: return(new Guid(propertyValue)); case StorageType.Int16: return(XmlConvert.ToInt16(propertyValue)); case StorageType.Int32: return(XmlConvert.ToInt32(propertyValue)); case StorageType.Int64: return(XmlConvert.ToInt64(propertyValue)); case StorageType.Single: return(XmlConvert.ToSingle(propertyValue)); case StorageType.String: return(propertyValue); case StorageType.SByte: return(XmlConvert.ToSByte(propertyValue)); case StorageType.TimeSpan: return(XmlConvert.ToTimeSpan(propertyValue)); case StorageType.Type: return(Type.GetType(propertyValue, true)); case StorageType.UInt16: return(XmlConvert.ToUInt16(propertyValue)); case StorageType.UInt32: return(XmlConvert.ToUInt32(propertyValue)); case StorageType.UInt64: return(XmlConvert.ToUInt64(propertyValue)); case StorageType.Uri: return(Util.CreateUri(propertyValue, UriKind.RelativeOrAbsolute)); case StorageType.XDocument: return(0 < propertyValue.Length ? System.Xml.Linq.XDocument.Parse(propertyValue) : new System.Xml.Linq.XDocument()); case StorageType.XElement: return(System.Xml.Linq.XElement.Parse(propertyValue)); #if !ASTORIA_LIGHT case StorageType.Binary: Debug.Assert(null != knownTypes[(int)StorageType.Binary], "null typeof(System.Data.Linq.Binary)"); return(Activator.CreateInstance(knownTypes[(int)StorageType.Binary], Convert.FromBase64String(propertyValue))); #endif default: Debug.Assert(false, "new StorageType without update to knownTypes"); return(propertyValue); } } catch (FormatException ex) { propertyValue = (0 == propertyValue.Length ? "String.Empty" : "String"); throw Error.InvalidOperation(Strings.Deserialize_Current(propertyType.ToString(), propertyValue), ex); } catch (OverflowException ex) { propertyValue = (0 == propertyValue.Length ? "String.Empty" : "String"); throw Error.InvalidOperation(Strings.Deserialize_Current(propertyType.ToString(), propertyValue), ex); } }
internal override object Parse(string text) { return(Util.CreateUri(text, UriKind.RelativeOrAbsolute)); }