public ClientApiGenerator(object sourceSchema, EdmItemCollection edmItemCollection, EntityClassGenerator generator, List <EdmSchemaError> errors, string namespacePrefix)
{
Debug.Assert(edmItemCollection != null, "edmItemCollection is null");
Debug.Assert(generator != null, "generator is null");
Debug.Assert(errors != null, "errors is null");
_edmItemCollection = edmItemCollection;
_generator = generator;
_errors = errors;
_attributeEmitter = new AttributeEmitter(_typeReference);
_namespacePrefix = namespacePrefix;
// generate map for inherited types and prefixed types
_namespaceMap = new Dictionary <string, string>();
_onTypeGenerated = new EventHandler <TypeGeneratedEventArgs>(TypeGeneratedEventHandler);
_onPropertyGenerated = new EventHandler <PropertyGeneratedEventArgs>(PropertyGeneratedEventHandler);
//// This constructor can be called multiple times with the same EntityClassGenerator. That is, many instances
//// of the ClientApiGenerator can add handlers to one instance of the EntityClassGenerator.
//// Make sure the handlers are not left on the EntityClassGenerator after the ClientApiGenerator is no longer in use.
//// See the Dispose method
_generator.OnTypeGenerated += _onTypeGenerated;
_generator.OnPropertyGenerated += _onPropertyGenerated;
}
private static string GenerateCode(XmlReader reader, string nameSpace)
{
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode)
{
Version = DataServiceCodeVersion.V2
};
StringWriter targetWriter = new StringWriter();
try
{
IList <EdmSchemaError> list = generator.GenerateCode(reader, targetWriter, nameSpace);
if (list.Count > 0)
{
throw new DisplayToUserException(string.Concat(new object[] { "Bad schema: ", list[0].Message, " (line ", list[0].Line, ")" }));
}
}
catch (MetadataException exception)
{
throw new DisplayToUserException("MetadataException: " + exception.Message);
}
catch (XmlSchemaValidationException exception2)
{
throw new DisplayToUserException("This schema is unsupported.\r\n\r\nEntityClassGenerator returned the following error: " + exception2.Message);
}
catch (FileNotFoundException exception3)
{
if (exception3.Message.Contains("System.Data.Services.Design"))
{
throw new DisplayToUserException("Cannot load System.Data.Services.Design.dll. (A possible cause is installing only the .NET Framework Client Profile instead of the full .NET Framework.)");
}
throw;
}
return(targetWriter.ToString());
}
private static string GenerateCode(XmlReader reader, string nameSpace)
{
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode) {
Version = DataServiceCodeVersion.V2
};
StringWriter targetWriter = new StringWriter();
try
{
IList<EdmSchemaError> list = generator.GenerateCode(reader, targetWriter, nameSpace);
if (list.Count > 0)
{
throw new DisplayToUserException(string.Concat(new object[] { "Bad schema: ", list[0].Message, " (line ", list[0].Line, ")" }));
}
}
catch (MetadataException exception)
{
throw new DisplayToUserException("MetadataException: " + exception.Message);
}
catch (XmlSchemaValidationException exception2)
{
throw new DisplayToUserException("This schema is unsupported.\r\n\r\nEntityClassGenerator returned the following error: " + exception2.Message);
}
catch (FileNotFoundException exception3)
{
if (exception3.Message.Contains("System.Data.Services.Design"))
{
throw new DisplayToUserException("Cannot load System.Data.Services.Design.dll. (A possible cause is installing only the .NET Framework Client Profile instead of the full .NET Framework.)");
}
throw;
}
return targetWriter.ToString();
}
public void UnitTest_EntityClassGenerator()
{
var auditableEntityType = typeof(IGetListItemsRequestV01);
var entityDeclarationTypes = auditableEntityType.Assembly.DefinedTypes.Where(type => Attribute.IsDefined(type, typeof(EntityContractDeclarationAttribute))).ToArray();
var targetBaseFolderPath = Path.GetFullPath(@"../../../../Product.Generated/");
var targetBaseFolder = new DirectoryInfo(targetBaseFolderPath);
if (!targetBaseFolder.Exists)
{
targetBaseFolder.Create();
}
foreach (var typeDeclaringEntityContract in entityDeclarationTypes)
{
var entityCodeGenModel = new EntityContractDeclarationModel(typeDeclaringEntityContract);
var subDirPath = entityCodeGenModel.DeclaringInterfaceType.Namespace.Replace(auditableEntityType.Namespace, "").TrimStart('.').Replace(".", @"/");
var targetDirectory = string.IsNullOrWhiteSpace(subDirPath)
? targetBaseFolder
: targetBaseFolder.CreateSubdirectory(subDirPath);
//string filePath = Path.Combine(targetDirectory.FullName, $"{entityCodeGenModel.DeclaringInterfaceType.Namespace.Replace(auditableEntityType.Namespace, "").TrimStart('.')}.{entityCodeGenModel.FriendlyName}.cs");
string filePath = Path.Combine(targetDirectory.FullName, $"{entityCodeGenModel.FriendlyName}.cs");
using (System.IO.FileStream fs = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite))
{
using (var writer = new System.IO.StreamWriter(fs, Encoding.UTF8, 4096))
{
var entityClassGenerator = new EntityClassGenerator();
entityClassGenerator.Generate(writer, entityCodeGenModel, entityCodeGenModel.EntityContractDeclarationAttribute.Namespace ?? "ProductName.Data.Model");
}
}
}
}
public async System.Threading.Tasks.Task Run()
{
// root file path
var rootFilePath = "src/SDK/Foundation";
var entities = Config["entities"];
EntityFactoryGenerator.GenerateEntityFactory(entities, rootFilePath, CompilationContainer);
// generate entities
foreach (var entity in entities)
{
var entityGroup = entity["group_id"].GetStringValue().ToPascal();
var entityNamePascal = entity["_key"].GetStringValue().ToPascal();
// generate entity enums
EnumGenerator.GenerateEnums(entity, rootFilePath, entityGroup, entityNamePascal, CompilationContainer);
// generate entity class
EntityClassGenerator.GenerateEntityClass(entity, entityNamePascal, rootFilePath, entityGroup, CompilationContainer);
if (entity["methods"].Any())
{
EntityRepositoryGenerator.GenerateRepository(entity, entityNamePascal, rootFilePath, entityGroup, CompilationContainer);
}
}
await CompilationContainer.Compile();
CompilationContainer.WriteFiles();
}
private async Task AddGeneratedCodeAsync(string metadataUri, string outputDirectory, Common.LanguageOption languageOption, ServiceConfiguration serviceConfiguration)
{
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Generating Client Proxy ...");
var generator = new EntityClassGenerator((System.Data.Services.Design.LanguageOption)languageOption)
{
UseDataServiceCollection = serviceConfiguration.UseDataServiceCollection,
Version = DataServiceCodeVersion.V3
};
// Set up XML secure resolver
var xmlUrlResolver = new XmlUrlResolver
{
Credentials = System.Net.CredentialCache.DefaultNetworkCredentials
};
var permissionSet = new PermissionSet(System.Security.Permissions.PermissionState.Unrestricted);
var settings = new XmlReaderSettings
{
XmlResolver = new XmlSecureResolver(xmlUrlResolver, permissionSet)
};
using (var reader = XmlReader.Create(metadataUri, settings))
{
var tempFile = Path.GetTempFileName();
var noErrors = true;
using (StreamWriter writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, serviceConfiguration.NamespacePrefix);
await writer.FlushAsync();
if (errors != null && errors.Any())
{
noErrors = false;
foreach (var err in errors)
{
await MessageLogger.WriteMessageAsync(LogMessageCategory.Warning, err.Message);
}
await MessageLogger.WriteMessageAsync(LogMessageCategory.Warning, "Client Proxy for OData V3 was not generated.");
}
}
if (noErrors)
{
var ext = languageOption == Common.LanguageOption.GenerateCSharpCode
? ".cs"
: ".vb";
var outputFile = Path.Combine(outputDirectory, this.GeneratedFileNamePrefix(serviceConfiguration.GeneratedFileNamePrefix) + ext);
await FileHandler.AddFileAsync(tempFile, outputFile, new ODataFileOptions { OpenOnComplete = serviceConfiguration.OpenGeneratedFilesInIDE });
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Client Proxy for OData V3 was generated.");
}
}
}
public override async Task AddGeneratedClientCodeAsync()
{
await Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy ...").ConfigureAwait(false);
var generator = new EntityClassGenerator(this.TargetProjectLanguage)
{
UseDataServiceCollection = this.ServiceConfiguration.UseDataServiceCollection,
Version = DataServiceCodeVersion.V3
};
// Set up XML secure resolver
var xmlUrlResolver = new XmlUrlResolver
{
Credentials = System.Net.CredentialCache.DefaultNetworkCredentials
};
var permissionSet = new PermissionSet(System.Security.Permissions.PermissionState.Unrestricted);
var settings = new XmlReaderSettings
{
XmlResolver = new XmlSecureResolver(xmlUrlResolver, permissionSet)
};
using (var reader = XmlReader.Create(this.MetadataUri, settings))
{
var tempFile = Path.GetTempFileName();
var noErrors = true;
using (StreamWriter writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, this.ServiceConfiguration.NamespacePrefix);
await writer.FlushAsync().ConfigureAwait(false);
if (errors != null && errors.Any())
{
noErrors = false;
foreach (var err in errors)
{
await Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, err.Message).ConfigureAwait(false);
}
await Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, "Client Proxy for OData V3 was not generated.").ConfigureAwait(false);
}
}
if (noErrors)
{
var ext = this.TargetProjectLanguage == LanguageOption.GenerateCSharpCode
? ".cs"
: ".vb";
var outputFile = Path.Combine(GetReferenceFileFolder(), this.GeneratedFileNamePrefix + ext);
await Context.HandlerHelper.AddFileAsync(tempFile, outputFile, new AddFileOptions { OpenOnComplete = ServiceConfiguration.OpenGeneratedFilesInIDE }).ConfigureAwait(false);
await Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Client Proxy for OData V3 was generated.").ConfigureAwait(false);
}
}
}
private void InitializeSettings()
{
Classes = new EntityClassGenerator(LanguageOption.GenerateCSharpCode);
Code = new EntityCodeGenerator(LanguageOption.GenerateCSharpCode);
Views = new EntityViewGenerator(LanguageOption.GenerateCSharpCode);
Store = new EntityStoreSchemaGenerator(providerInvariantName, connectionString, "ShoppingModelStore");
Store.GenerateForeignKeyProperties = true;
}
public override async Task AddGeneratedClientCodeAsync()
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy for OData V3...");
var generator = new EntityClassGenerator(this.ServiceConfiguration.LanguageOption)
{
UseDataServiceCollection = this.ServiceConfiguration.UseDataServiceCollection,
Version = DataServiceCodeVersion.V3
};
using (var reader = ServiceConfiguration.GetXmlReaderForEndpoint())
{
var tempFile = Path.GetTempFileName();
var noErrors = true;
using (var writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, this.ServiceConfiguration.NamespacePrefix);
await writer.FlushAsync();
if (errors != null && errors.Any())
{
noErrors = false;
foreach (var err in errors)
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, err.Message);
}
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, "Client Proxy for OData V3 was not generated.");
}
}
if (noErrors)
{
var ext = this.ServiceConfiguration.LanguageOption == LanguageOption.GenerateCSharpCode
? ".cs"
: ".vb";
await Microsoft.VisualStudio.Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
var outputFile = Path.Combine(this.ReferenceFileFolder, this.GeneratedFileNamePrefix + ext);
await this.Context.HandlerHelper.AddFileAsync(tempFile, outputFile, new AddFileOptions { OpenOnComplete = this.Instance.ServiceConfig.OpenGeneratedFilesOnComplete });
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Client Proxy for OData V3 was generated.");
if (ServiceConfiguration.IncludeExtensionsT4File && this.ServiceConfiguration.LanguageOption == LanguageOption.GenerateCSharpCode)
{
await AddGeneratedClientExtensionsCodeAsync(outputFile);
}
}
}
}
public ClientApiGenerator(Schema sourceSchema, EdmItemCollection edmItemCollection, EntityClassGenerator generator, List <EdmSchemaError> errors)
{
Debug.Assert(sourceSchema != null, "sourceSchema is null");
Debug.Assert(edmItemCollection != null, "edmItemCollection is null");
Debug.Assert(generator != null, "generator is null");
Debug.Assert(errors != null, "errors is null");
_edmItemCollection = edmItemCollection;
_sourceSchema = sourceSchema;
_generator = generator;
_errors = errors;
_attributeEmitter = new AttributeEmitter(_typeReference);
}
public void Can_get_base_class_name(OwnershipTypes ownership, string expected)
{
var entityMetadata = new EntityMetadata
{
LogicalName = "entity",
OwnershipType = ownership
};
var generator = new EntityClassGenerator(entityMetadata);
Assert.Equal("Entity", generator.GenerateBaseClassName());
typeof(EntityMetadata).GetProperty("IsCustomEntity").SetValue(entityMetadata, true);
Assert.Equal(expected, generator.GenerateBaseClassName());
}
static string GenerateCode(XmlReader reader, string nameSpace)
{
// We're using EntityClassGenerator to generate C# code, which we'll compile in
// the BuildAssembly method. (Another solution is to generate IL directly via Reflection.Emit.)
var generator = new EntityClassGenerator (LanguageOption.GenerateCSharpCode);
var writer = new StringWriter ();
IList<EdmSchemaError> errors = generator.GenerateCode (reader, writer, nameSpace);
// If we encounter errors, we can just throw an exception.
if (errors.Count > 0)
throw new Exception ("Bad schema: " + errors [0].Message + " (line " + errors [0].Line + ")");
return writer.ToString ();
}
public void Can_generate()
{
var entityMetadata = new EntityMetadata
{
LogicalName = "businessunit",
SchemaName = "BusinessUnit",
OwnershipType = OwnershipTypes.None
};
typeof(EntityMetadata).GetProperty("PrimaryIdAttribute").SetValue(entityMetadata, "businessunitid");
typeof(EntityMetadata).GetProperty("Attributes").SetValue(entityMetadata, new AttributeMetadata[] { });
var result = new EntityClassGenerator(entityMetadata).Generate();
_output.WriteLine(result);
Assert.Equal(ExpectedTemplate.EntityClass, result);
}
private async Task GenerateClientCodeWithoutDataSvcUtil(ConnectedServiceHandlerContext context, Project project)
{
await context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy ...");
ODataConnectedServiceInstance codeGenInstance = (ODataConnectedServiceInstance)context.ServiceInstance;
var address = codeGenInstance.Endpoint;
if (address.StartsWith("https:") || address.StartsWith("http"))
{
if (!address.EndsWith("$metadata"))
{
address = address.TrimEnd('/') + "/$metadata";
}
}
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode);
generator.UseDataServiceCollection = codeGenInstance.UseDataServiceCollection;
generator.Version = DataServiceCodeVersion.V3;
var referenceFolderPath = await CheckAndAddReferenceFolder(context, project);
string outputFile = Path.Combine(referenceFolderPath, "Reference.cs");
XmlReaderSettings settings = new XmlReaderSettings();
if (!String.IsNullOrEmpty(address))
{
XmlResolver resolver = new XmlUrlResolver();
{
resolver.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
}
settings.XmlResolver = resolver;
}
using (XmlReader reader = XmlReader.Create(address, settings))
{
using (StreamWriter writer = File.CreateText(outputFile))
{
var error = generator.GenerateCode(reader, writer, codeGenInstance.NamespacePrefix);
}
}
await context.HandlerHelper.AddFileAsync(outputFile, outputFile);
}
public async override Task AddGeneratedClientCodeAsync()
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy ...");
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode);
generator.UseDataServiceCollection = this.ServiceConfiguration.UseDataServiceCollection;
generator.Version = DataServiceCodeVersion.V3;
// Set up XML secure resolver
XmlUrlResolver xmlUrlResolver = new XmlUrlResolver()
{
Credentials = System.Net.CredentialCache.DefaultNetworkCredentials
};
PermissionSet permissionSet = new PermissionSet(System.Security.Permissions.PermissionState.Unrestricted);
XmlReaderSettings settings = new XmlReaderSettings()
{
XmlResolver = new XmlSecureResolver(xmlUrlResolver, permissionSet)
};
using (XmlReader reader = XmlReader.Create(this.MetadataUri, settings))
{
string tempFile = Path.GetTempFileName();
using (StreamWriter writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, this.ServiceConfiguration.NamespacePrefix);
await writer.FlushAsync();
if (errors != null && errors.Count() > 0)
{
foreach (var err in errors)
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, err.Message);
}
}
}
string outputFile = Path.Combine(GetReferenceFileFolder(), this.GeneratedFileNamePrefix + ".cs");
await this.Context.HandlerHelper.AddFileAsync(tempFile, outputFile, new AddFileOptions { OpenOnComplete = this.ServiceConfiguration.OpenGeneratedFilesInIDE });
}
}
public void Import(Stream input, string path)
{
var lookupTable = new FoxLookupTable(GlobalHashNameDictionary);
var foxFile = FoxFile.ReadFoxFile(input, lookupTable);
IEntityReferenceResolver referenceResolver = new EntityReferenceResolver();
Framework.Tpp.Classes.DataSet dataSet = null;
// Load each Entity.
ICollection <Entity> entities = new List <Entity>();
foreach (var entry in foxFile.Entities)
{
var entity = EntityFactory.MakeEntity(entry, entityTypes, unimplementedTypeTable, commandDispatcher, referenceResolver);
if (entity != null)
{
entities.Add(entity);
}
if (!(entity is Framework.Tpp.Classes.DataSet))
{
continue;
}
dataSet = entity as Framework.Tpp.Classes.DataSet;
dataSet.SetPath(path);
}
// Call OnLoaded() on the new Entities.
var autoResetEvent = commandDispatcher.DispatchCommand(new InitializeEntities(dataSet, entities));
autoResetEvent.WaitOne();
// Generate new Entity classes.
foreach (var unimplementedType in unimplementedTypeTable)
{
Debug.Log("Generating C# class for type " + unimplementedType.Key);
EntityClassGenerator.GenerateEntityClass(unimplementedType.Value);
}
}
internal static string TestConnectionInternal(IConnectionInfo r)
{
IList <EdmSchemaError> list;
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode)
{
Version = DataServiceCodeVersion.V2
};
StringWriter targetWriter = new StringWriter();
using (new PushDefaultWebProxy())
{
using (XmlReader reader = GetSchemaReader(r))
{
list = generator.GenerateCode(reader, targetWriter, null);
}
}
if (list.Count == 0)
{
return(null);
}
return(list.First <EdmSchemaError>().Message);
}
private static void CodeGen(FileInfo edmxFile, LanguageOption languageOption)
{
XDocument xdoc = XDocument.Load(edmxFile.FullName);
XElement c = GetCsdlFromEdmx(xdoc);
Version v = _namespaceManager.GetVersionFromEDMXDocument(xdoc);
StringWriter sw = new StringWriter();
IList <EdmSchemaError> errors = null;
//
// code-gen uses different classes for V1 and V2 of the EF
//
if (v == EntityFrameworkVersions.Version1)
{
// generate code
EntityClassGenerator codeGen = new EntityClassGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw);
}
else if (v == EntityFrameworkVersions.Version2)
{
EntityCodeGenerator codeGen = new EntityCodeGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw);
}
else if (v == EntityFrameworkVersions.Version3)
{
EntityCodeGenerator codeGen = new EntityCodeGenerator(languageOption);
errors = codeGen.GenerateCode(c.CreateReader(), sw, EntityFrameworkVersions.Version3);
}
// write out code-file
string outputFileName = GetFileNameWithNewExtension(edmxFile,
GetFileExtensionForLanguageOption(languageOption));
File.WriteAllText(outputFileName, sw.ToString());
// output errors
WriteErrors(errors);
}
public async override Task AddGeneratedClientCode()
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy ...");
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode);
generator.UseDataServiceCollection = this.ServiceConfiguration.UseDataServiceCollection;
generator.Version = DataServiceCodeVersion.V3;
XmlReaderSettings settings = new XmlReaderSettings()
{
XmlResolver = new XmlUrlResolver()
{
Credentials = System.Net.CredentialCache.DefaultNetworkCredentials
}
};
using (XmlReader reader = XmlReader.Create(this.MetadataUri, settings))
{
string tempFile = Path.GetTempFileName();
using (StreamWriter writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, this.ServiceConfiguration.NamespacePrefix);
await writer.FlushAsync();
if (errors != null && errors.Count() > 0)
{
foreach (var err in errors)
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, err.Message);
}
}
}
string outputFile = Path.Combine(GetReferenceFileFolder(), this.GeneratedFileNamePrefix + ".cs");
await this.Context.HandlerHelper.AddFileAsync(tempFile, outputFile);
}
}
internal static string TestConnectionInternal(IConnectionInfo r)
{
IList<EdmSchemaError> list;
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode) {
Version = DataServiceCodeVersion.V2
};
StringWriter targetWriter = new StringWriter();
using (new PushDefaultWebProxy())
{
using (XmlReader reader = GetSchemaReader(r))
{
list = generator.GenerateCode(reader, targetWriter, null);
}
}
if (list.Count == 0)
{
return null;
}
return list.First<EdmSchemaError>().Message;
}
public override async Task AddGeneratedClientCode()
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy for OData V3...");
var generator = new EntityClassGenerator(this.ServiceConfiguration.LanguageOption)
{
UseDataServiceCollection = this.ServiceConfiguration.UseDataServiceCollection,
Version = DataServiceCodeVersion.V3
};
var xmlUrlResolver = new XmlUrlResolver
{
Credentials = this.UseNetworkCredentials ? new NetworkCredential(this.NetworkCredentialsUserName, this.NetworkCredentialsPassword, this.NetworkCredentialsDomain) : System.Net.CredentialCache.DefaultNetworkCredentials
};
if (this.UseWebProxy)
{
xmlUrlResolver.Proxy = new WebProxy(this.WebProxyUri, true);
if (this.UseWebProxyCredentials)
{
xmlUrlResolver.Proxy = new WebProxy(this.WebProxyUri, true, new string[0], new NetworkCredential
{
UserName = WebProxyNetworkCredentialsUserName,
Password = WebProxyNetworkCredentialsPassword,
Domain = WebProxyNetworkCredentialsDomain
});
}
else
{
xmlUrlResolver.Proxy = new WebProxy(this.WebProxyUri);
}
}
var permissionSet = new PermissionSet(System.Security.Permissions.PermissionState.Unrestricted);
var settings = new XmlReaderSettings()
{
XmlResolver = new XmlSecureResolver(xmlUrlResolver, permissionSet)
};
using (var reader = XmlReader.Create(this.MetadataUri, settings))
{
var tempFile = Path.GetTempFileName();
var noErrors = true;
using (var writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, this.ServiceConfiguration.NamespacePrefix);
await writer.FlushAsync();
if (errors != null && errors.Any())
{
noErrors = false;
foreach (var err in errors)
{
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, err.Message);
}
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, "Client Proxy for OData V3 was not generated.");
}
}
if (noErrors)
{
var ext = this.ServiceConfiguration.LanguageOption == LanguageOption.GenerateCSharpCode
? ".cs"
: ".vb";
var outputFile = Path.Combine(GetReferenceFileFolder(), this.GeneratedFileNamePrefix + ext);
await this.Context.HandlerHelper.AddFileAsync(tempFile, outputFile, new AddFileOptions { OpenOnComplete = this.Instance.ServiceConfig.OpenGeneratedFilesOnComplete });
await this.Context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Client Proxy for OData V3 was generated.");
if (ServiceConfiguration.IncludeExtensionsT4File && this.ServiceConfiguration.LanguageOption == LanguageOption.GenerateCSharpCode)
{
await AddGeneratedClientExtensionsCode(outputFile);
}
}
}
}
private async Task GenerateClientCodeWithoutDataSvcUtil(ConnectedServiceHandlerContext context, Project project)
{
await context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy ...");
ODataConnectedServiceInstance codeGenInstance = (ODataConnectedServiceInstance)context.ServiceInstance;
string address = codeGenInstance.Endpoint;
if (address == null)
{
throw new Exception("Please input the service endpoint");
}
if (address.StartsWith("https:") || address.StartsWith("http"))
{
if (!address.EndsWith("$metadata"))
{
address = address.TrimEnd('/') + "/$metadata";
}
}
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode);
generator.UseDataServiceCollection = codeGenInstance.UseDataServiceCollection;
generator.Version = DataServiceCodeVersion.V3;
string referenceFolderPath = GetReferenceFolderName(context, project);
string outputFile = Path.Combine(referenceFolderPath, "Reference.cs");
XmlReaderSettings settings = new XmlReaderSettings();
if (!String.IsNullOrEmpty(address))
{
XmlResolver resolver = new XmlUrlResolver();
{
resolver.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
}
settings.XmlResolver = resolver;
}
XmlReader reader = null;
try
{
reader = XmlReader.Create(address, settings);
string tempFile = Path.GetTempFileName();
using (StreamWriter writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, codeGenInstance.NamespacePrefix);
if (errors != null && errors.Count() > 0)
{
foreach (var err in errors)
{
await context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning, err.Message);
}
}
}
reader.Close();
await context.HandlerHelper.AddFileAsync(tempFile, outputFile);
}
catch (WebException e)
{
throw new Exception(string.Format("Cannot access {0}", address), e);
}
finally
{
if (reader != null)
{
reader.Dispose();
reader = null;
}
}
}
private async Task GenerateClientCodeWithoutDataSvcUtil(ConnectedServiceHandlerContext context, Project project)
{
await context.Logger.WriteMessageAsync(LoggerMessageCategory.Information, "Generating Client Proxy ...");
ODataConnectedServiceInstance codeGenInstance = (ODataConnectedServiceInstance)context.ServiceInstance;
var address = codeGenInstance.Endpoint;
if (address.StartsWith("https:") || address.StartsWith("http"))
{
if (!address.EndsWith("$metadata"))
{
address = address.TrimEnd('/') + "/$metadata";
}
}
EntityClassGenerator generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode);
generator.UseDataServiceCollection = codeGenInstance.UseDataServiceCollection;
generator.Version = DataServiceCodeVersion.V3;
var referenceFolderPath = await CheckAndAddReferenceFolder(context, project);
string outputFile = Path.Combine(referenceFolderPath, "Reference.cs");
XmlReaderSettings settings = new XmlReaderSettings();
if (!String.IsNullOrEmpty(address))
{
XmlResolver resolver = new XmlUrlResolver();
{
resolver.Credentials = System.Net.CredentialCache.DefaultNetworkCredentials;
}
settings.XmlResolver = resolver;
}
using (XmlReader reader = XmlReader.Create(address, settings))
{
using (StreamWriter writer = File.CreateText(outputFile))
{
var error = generator.GenerateCode(reader, writer, codeGenInstance.NamespacePrefix);
}
}
await context.HandlerHelper.AddFileAsync(outputFile, outputFile);
}
/// <summary>
/// Generates proxy classes
/// </summary>
/// <param name="generatorParams"></param>
public void GenerateClientProxyClasses(GeneratorParams generatorParams)
{
_logger.LogInformation(Resources.Generating_Client_Proxy____);
try
{
var edmxTmpFile = GetMetadata(generatorParams, out var version);
if (version == Constants.EdmxVersion4)
{
throw new ArgumentException(string.Format(Resources.Wrong_edx_version, version));
}
var generator = new EntityClassGenerator(LanguageOption.GenerateCSharpCode)
{
UseDataServiceCollection = true,
Version = DataServiceCodeVersion.V3
};
// Set up XML secure resolver
var xmlUrlResolver = new XmlUrlResolver
{
Credentials = CredentialCache.DefaultNetworkCredentials
};
var permissionSet = new PermissionSet(System.Security.Permissions.PermissionState.Unrestricted);
var settings = new XmlReaderSettings
{
XmlResolver = new XmlSecureResolver(xmlUrlResolver, permissionSet)
};
var fileHandler = new FilesHandler();
using (var reader = XmlReader.Create(generatorParams.MetadataUri, settings))
{
var tempFile = Path.GetTempFileName();
var noErrors = true;
using (StreamWriter writer = File.CreateText(tempFile))
{
var errors = generator.GenerateCode(reader, writer, generatorParams.NamespacePrefix);
writer.Flush();
if (errors != null && errors.Any())
{
noErrors = false;
foreach (var err in errors)
{
_logger.LogError(err.Message);
}
_logger.LogError(Resources.Client_Proxy_for_OData_V3_was_not_generated_);
}
}
if (noErrors)
{
var csFile = new FileInfo(Path.Combine(generatorParams.OutputDir, generatorParams.OutputFilename + ".cs"));
_logger.LogInformation(string.Format(Resources.Writing_file__0_, csFile.FullName));
fileHandler.AddFileAsync(tempFile, csFile.FullName).ConfigureAwait(true);
var edmxFile = new FileInfo(Path.Combine(generatorParams.OutputDir, generatorParams.OutputFilename + ".edmx"));
_logger.LogInformation(string.Format(Resources.Writing_file__0_, edmxFile.FullName));
fileHandler.AddFileAsync(edmxTmpFile, edmxFile.FullName).ConfigureAwait(true);
foreach (var pluginCommand in generatorParams.Plugins)
{
var plugin = PluginCreator.Create(_logger, generatorParams, pluginCommand);
plugin.Execute();
}
}
}
_logger.LogInformation(Resources.Client_Proxy_for_OData_V3_was_generated_);
}
catch (Exception e)
{
_logger.LogCritical(Resources.Errors_during_generation_Client_Proxy_for_OData_V3, e);
throw;
}
}
