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; } } }
/// <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; } }