private XmlReader GetXmlReader (string url)
{
XmlResolver res = new XmlUrlResolver ();
Uri uri = res.ResolveUri (null, url);
Stream s = res.GetEntity (uri, null, typeof (Stream)) as Stream;
XmlTextReader xtr = new XmlTextReader (uri.ToString (), s);
xtr.XmlResolver = res;
XmlValidatingReader xvr = new XmlValidatingReader (xtr);
xvr.XmlResolver = res;
xvr.ValidationType = ValidationType.None;
return xvr;
}
private static Version GetMetadataVersion(GeneratorParams generatorParams)
{
if (string.IsNullOrEmpty(generatorParams.MetadataDocumentUri))
{
throw new ArgumentNullException("OData Service Endpoint", Resources.Please_input_the_metadata_document_address);
}
if (File.Exists(generatorParams.MetadataDocumentUri))
{
generatorParams.MetadataDocumentUri = new FileInfo(generatorParams.MetadataDocumentUri).FullName;
}
if (generatorParams.MetadataDocumentUri.StartsWith("https:", StringComparison.Ordinal) ||
generatorParams.MetadataDocumentUri.StartsWith("http", StringComparison.Ordinal))
{
if (!generatorParams.MetadataDocumentUri.EndsWith("$metadata", StringComparison.Ordinal))
{
generatorParams.MetadataDocumentUri = generatorParams.MetadataDocumentUri.TrimEnd('/') + "/$metadata";
}
}
Stream metadataStream;
var metadataUri = new Uri(generatorParams.MetadataDocumentUri);
if (!metadataUri.IsFile)
{
var webRequest = (HttpWebRequest)WebRequest.Create(metadataUri);
if (generatorParams.IncludeWebProxy)
{
var proxy = new WebProxy(generatorParams.WebProxyHost);
if (generatorParams.IncludeWebProxyNetworkCredentials)
{
proxy.Credentials = new NetworkCredential(
generatorParams.WebProxyNetworkCredentialsUsername,
generatorParams.WebProxyNetworkCredentialsPassword,
generatorParams.WebProxyNetworkCredentialsDomain);
}
webRequest.Proxy = proxy;
}
WebResponse webResponse = webRequest.GetResponse();
metadataStream = webResponse.GetResponseStream();
}
else
{
// Set up XML secure resolver
var xmlUrlResolver = new XmlUrlResolver
{
Credentials = CredentialCache.DefaultNetworkCredentials
};
metadataStream = (Stream)xmlUrlResolver.GetEntity(metadataUri, null, typeof(Stream));
}
var workFile = Path.GetTempFileName();
try
{
using (XmlReader reader = XmlReader.Create(metadataStream))
{
using (var writer = XmlWriter.Create(workFile))
{
while (reader.NodeType != XmlNodeType.Element)
{
reader.Read();
}
if (reader.EOF)
{
throw new InvalidOperationException(Resources.The_metadata_is_an_empty_file);
}
Constants.SupportedEdmxNamespaces.TryGetValue(reader.NamespaceURI, out var edmxVersion);
writer.WriteNode(reader, false);
return(edmxVersion);
}
}
}
catch (WebException e)
{
throw new InvalidOperationException(string.Format(Resources.Cannot_access_metadata, generatorParams.MetadataDocumentUri), e);
}
}
internal string GetMetadata(out Version edmxVersion)
{
if (string.IsNullOrEmpty(this.Endpoint))
{
throw new ArgumentNullException("OData Service Endpoint", string.Format(CultureInfo.InvariantCulture, Constants.InputServiceEndpointMsg));
}
if (this.Endpoint.StartsWith("https:", StringComparison.Ordinal) ||
this.Endpoint.StartsWith("http", StringComparison.Ordinal))
{
if (!this.Endpoint.Contains("$metadata"))
{
this.Endpoint = this.Endpoint.TrimEnd('/') + "/$metadata";
}
}
Stream metadataStream;
var metadataUri = new Uri(this.Endpoint);
if (!metadataUri.IsFile)
{
var webRequest = (HttpWebRequest)WebRequest.Create(metadataUri);
if (this.CustomHttpHeaders != null)
{
var headerElements = this.CustomHttpHeaders.Split(new [] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (var headerElement in headerElements)
{
// Trim header for empty spaces
var header = headerElement.Trim();
webRequest.Headers.Add(header);
}
}
if (IncludeWebProxy)
{
var proxy = new WebProxy(WebProxyHost);
if (IncludeWebProxyNetworkCredentials)
{
proxy.Credentials = new NetworkCredential(WebProxyNetworkCredentialsUsername, WebProxyNetworkCredentialsPassword, WebProxyNetworkCredentialsDomain);
}
webRequest.Proxy = proxy;
}
WebResponse webResponse = webRequest.GetResponse();
metadataStream = webResponse.GetResponseStream();
}
else
{
// Set up XML secure resolver
var xmlUrlResolver = new XmlUrlResolver
{
Credentials = CredentialCache.DefaultNetworkCredentials
};
metadataStream = (Stream)xmlUrlResolver.GetEntity(metadataUri, null, typeof(Stream));
}
var workFile = Path.GetTempFileName();
try
{
using (XmlReader reader = XmlReader.Create(metadataStream))
{
using (var writer = XmlWriter.Create(workFile))
{
while (reader.NodeType != XmlNodeType.Element)
{
reader.Read();
}
if (reader.EOF)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "The metadata is an empty file"));
}
Common.Constants.SupportedEdmxNamespaces.TryGetValue(reader.NamespaceURI, out edmxVersion);
writer.WriteNode(reader, false);
}
}
return(workFile);
}
catch (WebException e)
{
throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "Cannot access {0}", this.Endpoint), e);
}
finally
{
metadataStream?.Dispose();
}
}
static TextReader GetReader (string filename)
{
XmlResolver resolver = new XmlUrlResolver ();
Stream stream = resolver.GetEntity (resolver.ResolveUri (null, filename), null, typeof (Stream)) as Stream;
if (useDecentReader)
return new XmlSignatureStreamReader (
new StreamReader (stream));
else
return new StreamReader (stream);
}
private bool LoadSchema(string uri) {
uri = _NameTable.Add(uri);
if (_SchemaInfo.HasSchema(uri)) {
return false;
}
SchemaInfo schemaInfo = null;
XmlResolver resolver = new XmlUrlResolver();
Uri _baseUri = resolver.ResolveUri(null,_reader.BaseURI);
XmlReader reader = null;
try {
Uri ruri = resolver.ResolveUri(_baseUri, uri.Substring(x_schema.Length));
Stream stm = (Stream)resolver.GetEntity(ruri,null,null);
reader = new XmlTextReader(ruri.ToString(), stm, _NameTable);
schemaInfo = new SchemaInfo(_SchemaNames);
new Parser(null, _NameTable, _SchemaNames, validationEventHandler).Parse(reader, uri, schemaInfo);
}
catch(XmlException e) {
SendValidationEvent(Res.Sch_CannotLoadSchema, new string[] {uri, e.Message}, XmlSeverityType.Warning);
schemaInfo = null;
}
finally {
if (reader != null) {
reader.Close();
}
}
if (schemaInfo != null && schemaInfo.ErrorCount == 0) {
_SchemaInfo.Add(uri, schemaInfo, validationEventHandler);
return true;
}
return false;
}
