public void TestAddGeneratedClientCode_PassesServiceConfigOptionsToCodeGenerator(
bool useDSC, bool ignoreUnexpected, bool enableNamingAlias,
string namespacePrefix, bool makeTypesInternal)
{
var handlerHelper = new TestConnectedServiceHandlerHelper();
var codeGenFactory = new TestODataT4CodeGeneratorFactory();
var serviceConfig = new ServiceConfigurationV4()
{
UseDataServiceCollection = useDSC,
IgnoreUnexpectedElementsAndAttributes = ignoreUnexpected,
EnableNamingAlias = enableNamingAlias,
NamespacePrefix = namespacePrefix,
MakeTypesInternal = makeTypesInternal,
IncludeT4File = false
};
var codeGenDescriptor = SetupCodeGenDescriptor(serviceConfig, "TestService", codeGenFactory, handlerHelper);
codeGenDescriptor.AddGeneratedClientCodeAsync().Wait();
var generator = codeGenFactory.LastCreatedInstance;
Assert.AreEqual(useDSC, generator.UseDataServiceCollection);
Assert.AreEqual(enableNamingAlias, generator.EnableNamingAlias);
Assert.AreEqual(ignoreUnexpected, generator.IgnoreUnexpectedElementsAndAttributes);
Assert.AreEqual(makeTypesInternal, generator.MakeTypesInternal);
Assert.AreEqual(namespacePrefix, generator.NamespacePrefix);
Assert.AreEqual(MetadataUri, generator.MetadataDocumentUri);
Assert.AreEqual(ODataT4CodeGenerator.LanguageOption.CSharp, generator.TargetLanguage);
}
/// <summary>
/// Create the service configuration according to the edmx version.
/// </summary>
/// <returns>If the edm version is less than 4.0, returns a ServiceConfiguration, else, returns ServiceConfigurationV4</returns>
private ServiceConfiguration CreateServiceConfiguration()
{
ServiceConfiguration serviceConfiguration;
if (ConfigODataEndpointViewModel.EdmxVersion == Common.Constants.EdmxVersion4)
{
var ServiceConfigurationV4 = new ServiceConfigurationV4();
ServiceConfigurationV4.IgnoreUnexpectedElementsAndAttributes = AdvancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes;
ServiceConfigurationV4.EnableNamingAlias = AdvancedSettingsViewModel.EnableNamingAlias;
ServiceConfigurationV4.IncludeT4File = AdvancedSettingsViewModel.IncludeT4File;
serviceConfiguration = ServiceConfigurationV4;
}
else
{
serviceConfiguration = new ServiceConfiguration();
}
serviceConfiguration.ServiceName = ConfigODataEndpointViewModel.ServiceName;
serviceConfiguration.Endpoint = ConfigODataEndpointViewModel.Endpoint;
serviceConfiguration.EdmxVersion = ConfigODataEndpointViewModel.EdmxVersion;
serviceConfiguration.UseDataServiceCollection = AdvancedSettingsViewModel.UseDataServiceCollection;
serviceConfiguration.GeneratedFileNamePrefix = AdvancedSettingsViewModel.GeneratedFileName;
serviceConfiguration.UseNameSpacePrefix = AdvancedSettingsViewModel.UseNamespacePrefix;
if (AdvancedSettingsViewModel.UseNamespacePrefix && !string.IsNullOrEmpty(AdvancedSettingsViewModel.NamespacePrefix))
{
serviceConfiguration.NamespacePrefix = AdvancedSettingsViewModel.NamespacePrefix;
}
return(serviceConfiguration);
}
public void Test_GeneratesAndSavesCodeFileWithoutProxy()
{
var serviceName = "MyService";
ServiceConfiguration serviceConfig = new ServiceConfigurationV4()
{
UseDataServiceCollection = false,
ServiceName = serviceName,
GeneratedFileNamePrefix = "MyFile",
IncludeT4File = false,
Endpoint = "http://localhost:9000"
};
var testT4Factory = new TestODataT4NetworkCodeGeneratorFactory();
testT4Factory.EDMX = ODataT4CodeGeneratorTestDescriptors.Simple.Metadata;
var handlerHelper = new TestConnectedServiceHandlerHelper();
var codeGenDescriptor = SetupCodeGenDescriptor(serviceConfig, serviceName,
testT4Factory, handlerHelper);
codeGenDescriptor.AddGeneratedClientCodeAsync().Wait();
using (var reader = new StreamReader(handlerHelper.AddedFileInputFileName))
{
var generatedCode = reader.ReadToEnd();
ODataT4CodeGeneratorTestDescriptors.Simple.Verify(generatedCode, true /*isCSharp*/, false /*useDSC*/);
var requestGenerator = (TestODataT4NetworkCodeGeneratorFactory.TestHttpCreator)ODataT4CodeGenerator.CodeGenerationContext.RequestCreator;
var proxy = requestGenerator.mock.Object.Proxy;
Assert.IsNull(proxy);
Assert.AreEqual(Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "MyFile.cs"),
handlerHelper.AddedFileTargetFilePath);
}
}
public override async Task <ConnectedServiceInstance> GetFinishedServiceInstanceAsync()
{
// ensure that the data has been loaded from wizard pages and saved to UserSettings
if (this.Context.IsUpdating)
{
if (!this.OperationImportsViewModel.IsEntered)
{
await this.OperationImportsViewModel.OnPageEnteringAsync(null);
await this.OperationImportsViewModel.OnPageLeavingAsync(null);
}
if (!this.SchemaTypesViewModel.IsEntered)
{
await this.SchemaTypesViewModel.OnPageEnteringAsync(null);
await this.SchemaTypesViewModel.OnPageLeavingAsync(null);
}
if (!this.AdvancedSettingsViewModel.IsEntered)
{
await this.AdvancedSettingsViewModel.OnPageEnteringAsync(null);
await this.AdvancedSettingsViewModel.OnPageLeavingAsync(null);
}
}
this.UserSettings.Save();
this.ServiceInstance.InstanceId = AdvancedSettingsViewModel.GeneratedFileNamePrefix;
this.ServiceInstance.Name = ConfigODataEndpointViewModel.ServiceName;
this.ServiceInstance.MetadataTempFilePath = ConfigODataEndpointViewModel.MetadataTempPath;
this.ServiceInstance.ServiceConfig = this.CreateServiceConfiguration();
return(await Task.FromResult <ConnectedServiceInstance>(this.ServiceInstance));
}
public void TestDisableReaOonlyFieldsWhenUpdating()
{
ServiceConfigurationV4 savedConfig = GetTestConfig();
var context = new TestConnectedServiceProviderContext(true, savedConfig);
var wizard = new ODataConnectedServiceWizard(context);
// endpoint page
var endpointPage = wizard.ConfigODataEndpointViewModel;
endpointPage.OnPageEnteringAsync(new WizardEnteringArgs(null)).Wait();
var endpointView = endpointPage.View as ConfigODataEndpoint;
Assert.False(endpointView.ServiceName.IsEnabled);
Assert.False(endpointView.Endpoint.IsEnabled);
Assert.False(endpointView.OpenConnectedServiceJsonFileButton.IsEnabled);
// if endpoint is a http address, then file dialog should be disabled
savedConfig.Endpoint = "http://service";
endpointPage.OnPageEnteringAsync(null).Wait();
Assert.False(endpointView.OpenEndpointFileButton.IsEnabled);
// advanced settings page
var advancedPage = wizard.AdvancedSettingsViewModel;
advancedPage.OnPageEnteringAsync(new WizardEnteringArgs(endpointPage)).Wait();
var advancedView = advancedPage.View as AdvancedSettings;
Assert.False(advancedView.IncludeT4File.IsEnabled);
Assert.False(advancedView.GenerateMultipleFiles.IsEnabled);
}
public V4CodeGenDescriptor(ConnectedServiceHandlerContext context, Instance serviceInstance)
: base(context, serviceInstance)
{
this.ClientNuGetPackageName = Common.Constants.V4ClientNuGetPackage;
this.ClientDocUri = Common.Constants.V4DocUri;
this.ServiceConfiguration = base.Instance.ServiceConfig as ServiceConfigurationV4;
}
/// <summary>
/// Create the service configuration according to the edmx version.
/// </summary>
/// <returns>If the edm version is less than 4.0, returns a ServiceConfiguration, else, returns ServiceConfigurationV4</returns>
private ServiceConfiguration CreateServiceConfiguration()
{
ServiceConfiguration serviceConfiguration;
if (ConfigODataEndpointViewModel.EdmxVersion == Constants.EdmxVersion4)
{
var serviceConfigurationV4 = new ServiceConfigurationV4();
serviceConfigurationV4.CopyPropertiesFrom(UserSettings);
serviceConfigurationV4.ExcludedOperationImports = OperationImportsViewModel.ExcludedOperationImportsNames.ToList();
serviceConfigurationV4.ExcludedBoundOperations = SchemaTypesViewModel.ExcludedBoundOperationsNames.ToList();
serviceConfiguration = serviceConfigurationV4;
}
else
{
serviceConfiguration = new ServiceConfiguration();
serviceConfiguration.CopyPropertiesFrom(UserSettings);
}
serviceConfiguration.ExcludedSchemaTypes = SchemaTypesViewModel.ExcludedSchemaTypeNames.ToList();
serviceConfiguration.EdmxVersion = ConfigODataEndpointViewModel.EdmxVersion;
return(serviceConfiguration);
}
public void TestCopyPropertiesFromUserSettingsToServiceConfiguration()
{
var userSettings = CreateUserSettings();
var serviceConfig = new ServiceConfigurationV4();
serviceConfig.CopyPropertiesFrom(userSettings);
Assert.Equal("Key:Test", serviceConfig.CustomHttpHeaders);
Assert.True(serviceConfig.EnableNamingAlias);
Assert.Equal("http://test", serviceConfig.Endpoint);
Assert.Single(serviceConfig.ExcludedBoundOperations, "TestBoundOperation");
Assert.Single(serviceConfig.ExcludedOperationImports, "TestOperationImport");
Assert.Single(serviceConfig.ExcludedSchemaTypes, "TestSchemaType");
Assert.Equal("Test", serviceConfig.GeneratedFileNamePrefix);
Assert.True(serviceConfig.GenerateMultipleFiles);
Assert.True(serviceConfig.IgnoreUnexpectedElementsAndAttributes);
Assert.True(serviceConfig.IncludeCustomHeaders);
Assert.True(serviceConfig.IncludeT4File);
Assert.True(serviceConfig.IncludeWebProxy);
Assert.True(serviceConfig.IncludeWebProxyNetworkCredentials);
Assert.True(serviceConfig.MakeTypesInternal);
Assert.Equal("Test", serviceConfig.NamespacePrefix);
Assert.True(serviceConfig.OpenGeneratedFilesInIDE);
Assert.Equal("Test", serviceConfig.ServiceName);
Assert.True(serviceConfig.UseDataServiceCollection);
Assert.True(serviceConfig.UseNamespacePrefix);
Assert.Equal("Test", serviceConfig.WebProxyHost);
Assert.Equal("Test", serviceConfig.WebProxyNetworkCredentialsDomain);
Assert.Equal("Test", serviceConfig.WebProxyNetworkCredentialsPassword);
Assert.Equal("Test", serviceConfig.WebProxyNetworkCredentialsUsername);
}
private async Task GenerateCodeForV4Clients(GenerateOptions generateOptions, IConsole console)
{
var serviceConfigurationV4 = new ServiceConfigurationV4();
serviceConfigurationV4.Endpoint = generateOptions.MetadataUri;
serviceConfigurationV4.ServiceName = Constants.DefaultServiceName;
serviceConfigurationV4.GeneratedFileNamePrefix = generateOptions.FileName;
serviceConfigurationV4.CustomHttpHeaders = generateOptions.CustomHeaders;
serviceConfigurationV4.WebProxyHost = generateOptions.WebProxyHost;
serviceConfigurationV4.IncludeWebProxy = generateOptions.IncludeWebProxy;
serviceConfigurationV4.IncludeWebProxyNetworkCredentials = generateOptions.IncludeWebProxyNetworkCredentials;
serviceConfigurationV4.WebProxyNetworkCredentialsUsername = generateOptions.WebProxyNetworkCredentialsUsername;
serviceConfigurationV4.WebProxyNetworkCredentialsPassword = generateOptions.WebProxyNetworkCredentialsPassword;
serviceConfigurationV4.WebProxyNetworkCredentialsDomain = generateOptions.WebProxyNetworkCredentialsDomain;
serviceConfigurationV4.NamespacePrefix = generateOptions.NamespacePrefix;
serviceConfigurationV4.MakeTypesInternal = generateOptions.EnableInternal;
serviceConfigurationV4.GenerateMultipleFiles = generateOptions.MultipleFiles;
serviceConfigurationV4.ExcludedSchemaTypes = generateOptions.ExcludedSchemaTypes;
serviceConfigurationV4.ExcludedBoundOperations = generateOptions.ExcludedBoundOperations;
serviceConfigurationV4.ExcludedOperationImports = generateOptions.ExcludedOperationImports;
serviceConfigurationV4.IgnoreUnexpectedElementsAndAttributes = generateOptions.IgnoreUnexpectedElements;
serviceConfigurationV4.EnableNamingAlias = generateOptions.UpperCamelCase;
Project project = ProjectHelper.CreateProjectInstance(generateOptions.OutputDir);
BaseCodeGenDescriptor codeGenDescriptor = new CodeGenDescriptorFactory().Create(
Constants.EdmxVersion4,
new ODataCliFileHandler(new ODataCliMessageLogger(console), project),
new ODataCliMessageLogger(console),
new ODataCliPackageInstaller(project, new ODataCliMessageLogger(console)));
await codeGenDescriptor.AddNugetPackagesAsync().ConfigureAwait(false);
await codeGenDescriptor.AddGeneratedClientCodeAsync(generateOptions.MetadataUri, generateOptions.OutputDir, LanguageOption.GenerateCSharpCode, serviceConfigurationV4).ConfigureAwait(false);
}
public TestConnectedServiceProviderContext(bool isUpdating = false, ServiceConfigurationV4 savedData = null) : base()
{
this.savedData = savedData;
if (isUpdating)
{
UpdateContext = new ConnectedServiceUpdateContext(new Version(), new TestVsHierarchyItem());
}
}
public void TestAddGenerateClientCode_GeneratesMultipleFiles()
{
var serviceName = "MyService";
ServiceConfiguration serviceConfig = new ServiceConfigurationV4()
{
ServiceName = serviceName,
GeneratedFileNamePrefix = "Main",
GenerateMultipleFiles = true
};
var codeGen = new TestODataT4CodeGenerator();
var codeGenFactory = new TestODataT4CodeGeneratorFactory(codeGen);
var handlerHelper = new TestConnectedServiceHandlerHelper();
var codeGenDescriptor = SetupCodeGenDescriptor(serviceConfig, serviceName,
codeGenFactory, handlerHelper);
var template = new StringBuilder();
codeGen.MultipleFilesManager = ODataT4CodeGenerator.FilesManager.Create(null, template);
codeGen.MultipleFilesManager.StartNewFile("File1.cs", false);
template.Append("Contents1");
codeGen.MultipleFilesManager.EndBlock();
codeGen.MultipleFilesManager.StartNewFile("File2.cs", false);
template.Append("Contents2");
codeGen.MultipleFilesManager.EndBlock();
//The file manager expects the files to have been saved in the Temp directory
// when ODataT4CodeGenerator.TransformText() was called. Since we're using a dummy code generator
// we need to manually ensure those files exist
var file1TempPath = Path.Combine(Path.GetTempPath(), "File1.cs");
File.WriteAllText(file1TempPath, "Contents1");
var file2TempPath = Path.Combine(Path.GetTempPath(), "File2.cs");
File.WriteAllText(file2TempPath, "Contents2");
codeGenDescriptor.AddGeneratedClientCodeAsync().Wait();
var expectedMainFilePath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "Main.cs");
var mainFile = handlerHelper.AddedFiles.FirstOrDefault(f => f.CreatedFile == expectedMainFilePath);
Assert.IsNotNull(mainFile);
Assert.AreEqual("Generated code", File.ReadAllText(mainFile.SourceFile));
var expectedFile1Path = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "File1.cs");
var file1 = handlerHelper.AddedFiles.FirstOrDefault(f => f.CreatedFile == expectedFile1Path);
Assert.IsNotNull(file1);
Assert.AreEqual("Contents1", File.ReadAllText(file1.SourceFile));
var expectedFile2Path = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "File2.cs");
var file2 = handlerHelper.AddedFiles.FirstOrDefault(f => f.CreatedFile == expectedFile2Path);
Assert.IsNotNull(file2);
Assert.AreEqual("Contents2", File.ReadAllText(file2.SourceFile));
}
public void TestAddGeneratedClientCode_GeneratesT4TemplateFiles_WithIncludeT4File_WithExcludedBoundOperations(string lang, string referenceFile)
{
var serviceName = "MyService";
ServiceConfiguration serviceConfig = new ServiceConfigurationV4()
{
ServiceName = serviceName,
Endpoint = "https://service/$metadata",
GeneratedFileNamePrefix = "Reference",
IncludeT4File = true,
ExcludedBoundOperations = new List <string>()
{
"BoundOperation1(Type1)",
"BoundOperation2(Type2)",
"BoundOperation3(Type1)"
}
};
var codeGenFactory = new TestODataT4CodeGeneratorFactory();
var handlerHelper = new TestConnectedServiceHandlerHelper();
var codeGenDescriptor = SetupCodeGenDescriptor(serviceConfig, serviceName, codeGenFactory, handlerHelper,
lang == "cs" ? ODataT4CodeGenerator.LanguageOption.CSharp : ODataT4CodeGenerator.LanguageOption.VB);
codeGenDescriptor.AddGeneratedClientCodeAsync().Wait();
var ttIncludeSourcePath = Path.Combine(Directory.GetCurrentDirectory(), "Templates", "ODataT4CodeGenerator.ttinclude");
var ttIncludeOutputPath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "Reference.ttinclude");
var fileManagerSourcePath = Path.Combine(Directory.GetCurrentDirectory(), "Templates", "ODataT4CodeGenFilesManager.ttinclude");
var fileManagerOutputPath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "ODataT4CodeGenFilesManager.ttinclude");
var ttOutputPath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "Reference.tt");
var csdlFileName = String.Concat(serviceName, "Csdl.xml");
Assert.IsTrue(handlerHelper.AddedFiles.Contains((fileManagerOutputPath, fileManagerSourcePath)));
var ttInclude = handlerHelper.AddedFiles.FirstOrDefault(f => f.CreatedFile == ttIncludeOutputPath);
Assert.IsNotNull(ttInclude);
var ttIncludeOriginalText = File.ReadAllText(ttIncludeSourcePath);
var ttIncludeExpectedText = ttIncludeOriginalText.Replace("output extension=\".cs\"", $"output extension=\".{lang}\"");
var ttIncludeSavedText = File.ReadAllText(ttInclude.SourceFile);
Assert.AreEqual(ttIncludeExpectedText, ttIncludeSavedText);
var tt = handlerHelper.AddedFiles.FirstOrDefault(f => f.CreatedFile == ttOutputPath);
Assert.IsNotNull(tt);
var ttExpectedText = File.ReadAllText(Path.Combine(Directory.GetCurrentDirectory(), "CodeGeneration", referenceFile));
ttExpectedText = ttExpectedText.Replace("$$CsdlFullPath$$", Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, csdlFileName));
ttExpectedText = ttExpectedText.Replace("$$CsdlRelativePath$$", csdlFileName);
ttExpectedText = Regex.Replace(ttExpectedText, "(public const string ExcludedBoundOperations = )\"\";", "$1\"" + string.Join(",", (serviceConfig as ServiceConfigurationV4).ExcludedBoundOperations) + "\";");
var ttSavedText = File.ReadAllText(tt.SourceFile);
Assert.AreEqual(ttExpectedText, ttSavedText);
}
public ODataConnectedServiceWizard(ConnectedServiceProviderContext context)
{
this.Context = context;
this.userSettings = UserSettings.Load(context.Logger);
ConfigODataEndpointViewModel = new ConfigODataEndpointViewModel(this.userSettings);
AdvancedSettingsViewModel = new AdvancedSettingsViewModel();
if (this.Context.IsUpdating)
{
//Since ServiceConfigurationV4 is a derived type of ServiceConfiguration. So we can deserialize a ServiceConfiguration into a ServiceConfigurationV4.
ServiceConfigurationV4 serviceConfig = this.Context.GetExtendedDesignerData <ServiceConfigurationV4>();
ConfigODataEndpointViewModel.Endpoint = serviceConfig.Endpoint;
ConfigODataEndpointViewModel.EdmxVersion = serviceConfig.EdmxVersion;
ConfigODataEndpointViewModel.ServiceName = serviceConfig.ServiceName;
ConfigODataEndpointViewModel.CustomHttpHeaders = serviceConfig.CustomHttpHeaders;
var configODataEndpoint = (ConfigODataEndpointViewModel.View as ConfigODataEndpoint);
configODataEndpoint.IsEnabled = false;
//Restore the advanced settings to UI elements.
AdvancedSettingsViewModel.PageEntering += (sender, args) =>
{
var advancedSettingsViewModel = sender as AdvancedSettingsViewModel;
if (advancedSettingsViewModel != null)
{
AdvancedSettings advancedSettings = advancedSettingsViewModel.View as AdvancedSettings;
advancedSettingsViewModel.GeneratedFileName = serviceConfig.GeneratedFileNamePrefix;
advancedSettings.ReferenceFileName.IsEnabled = false;
advancedSettingsViewModel.UseNamespacePrefix = serviceConfig.UseNameSpacePrefix;
advancedSettingsViewModel.NamespacePrefix = serviceConfig.NamespacePrefix;
advancedSettingsViewModel.UseDataServiceCollection = serviceConfig.UseDataServiceCollection;
advancedSettingsViewModel.GenerateMultipleFiles = serviceConfig.GenerateMultipleFiles;
advancedSettings.GenerateMultipleFiles.IsEnabled = false;
if (serviceConfig.EdmxVersion == Common.Constants.EdmxVersion4)
{
advancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes = serviceConfig.IgnoreUnexpectedElementsAndAttributes;
advancedSettingsViewModel.EnableNamingAlias = serviceConfig.EnableNamingAlias;
advancedSettingsViewModel.IncludeT4File = serviceConfig.IncludeT4File;
advancedSettingsViewModel.MakeTypesInternal = serviceConfig.MakeTypesInternal;
advancedSettings.IncludeT4File.IsEnabled = false;
}
}
};
}
this.Pages.Add(ConfigODataEndpointViewModel);
this.Pages.Add(AdvancedSettingsViewModel);
this.IsFinishEnabled = true;
}
/// <summary>
/// Create the service configuration according to the edmx version.
/// </summary>
/// <returns>If the edm version is less than 4.0, returns a ServiceConfiguration, else, returns ServiceConfigurationV4</returns>
private ServiceConfiguration CreateServiceConfiguration()
{
ServiceConfiguration serviceConfiguration;
if (ConfigODataEndpointViewModel.EdmxVersion == Common.Constants.EdmxVersion4)
{
var serviceConfigurationV4 = new ServiceConfigurationV4
{
ExcludedOperationImports = OperationImportsViewModel.ExcludedOperationImportsNames.ToList(),
ExcludedBoundOperations = SchemaTypesViewModel.ExcludedBoundOperationsNames.ToList(),
IgnoreUnexpectedElementsAndAttributes =
AdvancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes,
EnableNamingAlias = AdvancedSettingsViewModel.EnableNamingAlias,
IncludeT4File = AdvancedSettingsViewModel.IncludeT4File,
OpenGeneratedFilesInIDE = AdvancedSettingsViewModel.OpenGeneratedFilesInIDE
};
serviceConfiguration = serviceConfigurationV4;
}
else
{
serviceConfiguration = new ServiceConfiguration();
}
serviceConfiguration.ExcludedSchemaTypes = SchemaTypesViewModel.ExcludedSchemaTypeNames.ToList();
serviceConfiguration.ServiceName = ConfigODataEndpointViewModel.ServiceName;
serviceConfiguration.Endpoint = ConfigODataEndpointViewModel.Endpoint;
serviceConfiguration.EdmxVersion = ConfigODataEndpointViewModel.EdmxVersion;
serviceConfiguration.CustomHttpHeaders = ConfigODataEndpointViewModel.CustomHttpHeaders;
serviceConfiguration.IncludeWebProxy = ConfigODataEndpointViewModel.IncludeWebProxy;
serviceConfiguration.WebProxyHost = ConfigODataEndpointViewModel.WebProxyHost;
serviceConfiguration.IncludeWebProxyNetworkCredentials = ConfigODataEndpointViewModel.IncludeWebProxyNetworkCredentials;
serviceConfiguration.WebProxyNetworkCredentialsUsername = ConfigODataEndpointViewModel.WebProxyNetworkCredentialsUsername;
serviceConfiguration.WebProxyNetworkCredentialsPassword = ConfigODataEndpointViewModel.WebProxyNetworkCredentialsPassword;
serviceConfiguration.WebProxyNetworkCredentialsDomain = ConfigODataEndpointViewModel.WebProxyNetworkCredentialsDomain;
serviceConfiguration.IncludeCustomHeaders = ConfigODataEndpointViewModel.IncludeCustomHeaders;
serviceConfiguration.UseDataServiceCollection = AdvancedSettingsViewModel.UseDataServiceCollection;
serviceConfiguration.GeneratedFileNamePrefix = AdvancedSettingsViewModel.GeneratedFileNamePrefix;
serviceConfiguration.UseNamespacePrefix = AdvancedSettingsViewModel.UseNamespacePrefix;
serviceConfiguration.MakeTypesInternal = AdvancedSettingsViewModel.MakeTypesInternal;
serviceConfiguration.OpenGeneratedFilesInIDE = AdvancedSettingsViewModel.OpenGeneratedFilesInIDE;
serviceConfiguration.GenerateMultipleFiles = AdvancedSettingsViewModel.GenerateMultipleFiles;
if (AdvancedSettingsViewModel.UseNamespacePrefix && !string.IsNullOrEmpty(AdvancedSettingsViewModel.NamespacePrefix))
{
serviceConfiguration.NamespacePrefix = AdvancedSettingsViewModel.NamespacePrefix;
}
return(serviceConfiguration);
}
internal static IEdmModel GetODataEdmModel(this ServiceConfigurationV4 serviceConfiguration, ConnectedServiceHandlerContext context = null)
{
using (var reader = serviceConfiguration.GetXmlReaderForEndpoint())
{
var edmxReaderSettings = new CsdlReaderSettings
{
IgnoreUnexpectedAttributesAndElements = serviceConfiguration.IgnoreUnexpectedElementsAndAttributes
};
if (!CsdlReader.TryParse(reader, Enumerable.Empty <IEdmModel>(), edmxReaderSettings, out var model, out var parseErrors))
{
if (context != null)
{
foreach (var error in parseErrors)
{
var task = context.Logger.WriteMessageAsync(LoggerMessageCategory.Warning,
error.ErrorMessage);
task.RunSynchronously();
}
}
}
public ODataConnectedServiceWizard(ConnectedServiceProviderContext context)
{
this.Context = context;
this.UserSettings = UserSettings.Load(context?.Logger);
// Since ServiceConfigurationV4 is a derived type of ServiceConfiguration. So we can deserialize a ServiceConfiguration into a ServiceConfigurationV4.
this._serviceConfig = this.Context?.GetExtendedDesignerData <ServiceConfigurationV4>();
ConfigODataEndpointViewModel = new ConfigODataEndpointViewModel(this.UserSettings, this);
AdvancedSettingsViewModel = new AdvancedSettingsViewModel(this.UserSettings);
SchemaTypesViewModel = new SchemaTypesViewModel(this.UserSettings);
OperationImportsViewModel = new OperationImportsViewModel(this.UserSettings);
OperationImportsViewModel.PageEntering += OperationImportsViewModel_PageEntering;
SchemaTypesViewModel.PageEntering += SchemaTypeSelectionViewModel_PageEntering;
SchemaTypesViewModel.PageLeaving += SchemaTypeSelectionViewModel_PageLeaving;
if (this.Context != null && this.Context.IsUpdating)
{
ConfigODataEndpointViewModel.Endpoint = this._serviceConfig?.Endpoint;
ConfigODataEndpointViewModel.EdmxVersion = this._serviceConfig?.EdmxVersion;
ConfigODataEndpointViewModel.ServiceName = this._serviceConfig?.ServiceName;
ConfigODataEndpointViewModel.CustomHttpHeaders = this._serviceConfig?.CustomHttpHeaders;
// Restore the main settings to UI elements.
ConfigODataEndpointViewModel.PageEntering += ConfigODataEndpointViewModel_PageEntering;
// The ViewModel should always be filled otherwise if the wizard is completed without visiting this page the generated code becomes wrong
AdvancedSettingsViewModel_PageEntering(AdvancedSettingsViewModel, EventArgs.Empty);
// Restore the advanced settings to UI elements.
AdvancedSettingsViewModel.PageEntering += AdvancedSettingsViewModel_PageEntering;
}
this.Pages.Add(ConfigODataEndpointViewModel);
this.Pages.Add(SchemaTypesViewModel);
this.Pages.Add(OperationImportsViewModel);
this.Pages.Add(AdvancedSettingsViewModel);
this.IsFinishEnabled = true;
}
/// <summary>
/// Create the service configuration according to the edmx version.
/// </summary>
/// <returns>If the edm version is less than 4.0, returns a ServiceConfiguration, else, returns ServiceConfigurationV4</returns>
private ServiceConfiguration CreateServiceConfiguration()
{
ServiceConfiguration serviceConfiguration;
if (ConfigODataEndpointViewModel.EdmxVersion == Common.Constants.EdmxVersion4)
{
serviceConfiguration = new ServiceConfigurationV4
{
IgnoreUnexpectedElementsAndAttributes =
AdvancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes,
EnableNamingAlias = AdvancedSettingsViewModel.EnableNamingAlias,
IncludeT4File = AdvancedSettingsViewModel.IncludeT4File
};
}
else
{
serviceConfiguration = new ServiceConfigurationV3
{
IncludeExtensionsT4File = AdvancedSettingsViewModel.IncludeExtensionsT4File,
FunctionImportsGenerator = AdvancedSettingsViewModel.FunctionImportsGenerator,
GenerateFunctionImports = AdvancedSettingsViewModel.GenerateFunctionImports
};
}
serviceConfiguration.LanguageOption = ConfigODataEndpointViewModel.UserSettings.LanguageOption;
serviceConfiguration.ServiceName = ConfigODataEndpointViewModel.UserSettings.ServiceName;
serviceConfiguration.Endpoint = ConfigODataEndpointViewModel.UserSettings.Endpoint;
serviceConfiguration.EdmxVersion = ConfigODataEndpointViewModel.EdmxVersion;
serviceConfiguration.UseDataServiceCollection = AdvancedSettingsViewModel.UseDataServiceCollection;
serviceConfiguration.GeneratedFileNamePrefix = AdvancedSettingsViewModel.GeneratedFileName;
serviceConfiguration.UseNameSpacePrefix = AdvancedSettingsViewModel.UseNamespacePrefix;
serviceConfiguration.OpenGeneratedFilesOnComplete = ConfigODataEndpointViewModel.UserSettings.OpenGeneratedFilesOnComplete;
if (AdvancedSettingsViewModel.UseNamespacePrefix && !string.IsNullOrEmpty(AdvancedSettingsViewModel.NamespacePrefix))
{
serviceConfiguration.NamespacePrefix = AdvancedSettingsViewModel.NamespacePrefix;
}
return(serviceConfiguration);
}
public ODataConnectedServiceWizard(ConnectedServiceProviderContext context)
{
Context = context;
// We only use most recently used endpoints from the config file saved in user's isolated storage
// The UserSettings constructor will load those endpoints
UserSettings = new UserSettings(context?.Logger);
// Since ServiceConfigurationV4 is a derived type of ServiceConfiguration,
// we can deserialize a ServiceConfiguration into a ServiceConfigurationV4.
ServiceConfig = Context?.GetExtendedDesignerData <ServiceConfigurationV4>();
ConfigODataEndpointViewModel = new ConfigODataEndpointViewModel(UserSettings);
AdvancedSettingsViewModel = new AdvancedSettingsViewModel(UserSettings);
SchemaTypesViewModel = new SchemaTypesViewModel(UserSettings);
OperationImportsViewModel = new OperationImportsViewModel(UserSettings);
OperationImportsViewModel.PageEntering += OperationImportsViewModel_PageEntering;
SchemaTypesViewModel.PageEntering += SchemaTypeSelectionViewModel_PageEntering;
SchemaTypesViewModel.PageLeaving += SchemaTypeSelectionViewModel_PageLeaving;
if (Context != null && Context.IsUpdating)
{
LoadUserSettingsFromServiceConfig();
ConfigODataEndpointViewModel.EdmxVersion = ServiceConfig?.EdmxVersion;
// Restore the main settings to UI elements.
ConfigODataEndpointViewModel.PageEntering += ConfigODataEndpointViewModel_PageEntering;
// The ViewModel should always be filled otherwise if the wizard is completed without visiting this page the generated code becomes wrong
AdvancedSettingsViewModel_PageEntering(AdvancedSettingsViewModel, EventArgs.Empty);
// Restore the advanced settings to UI elements.
AdvancedSettingsViewModel.PageEntering += AdvancedSettingsViewModel_PageEntering;
}
Pages.Add(ConfigODataEndpointViewModel);
Pages.Add(SchemaTypesViewModel);
Pages.Add(OperationImportsViewModel);
Pages.Add(AdvancedSettingsViewModel);
IsFinishEnabled = true;
}
public void TestAddGeneratedClientCode_GeneratesCsdlFiles(string lang)
{
var serviceName = "MyService";
ServiceConfiguration serviceConfig = new ServiceConfigurationV4()
{
ServiceName = serviceName,
Endpoint = "https://service/$metadata",
GeneratedFileNamePrefix = "Reference",
IncludeT4File = true
};
var codeGenFactory = new TestODataT4CodeGeneratorFactory();
var handlerHelper = new TestConnectedServiceHandlerHelper();
var codeGenDescriptor = SetupCodeGenDescriptor(serviceConfig, serviceName, codeGenFactory, handlerHelper,
lang == "cs" ? ODataT4CodeGenerator.LanguageOption.CSharp : ODataT4CodeGenerator.LanguageOption.VB);
codeGenDescriptor.AddGeneratedClientCodeAsync().Wait();
var csdlFilePath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, String.Concat(serviceName, "Csdl.xml"));
Assert.IsNotNull(csdlFilePath);
}
private static ServiceConfigurationV4 CreateServiceConfiguration()
{
var serviceConfig = new ServiceConfigurationV4();
serviceConfig.CustomHttpHeaders = "Key:Test";
serviceConfig.EdmxVersion = new Version(4, 0, 0, 0);
serviceConfig.EnableNamingAlias = true;
serviceConfig.Endpoint = "http://test";
serviceConfig.ExcludedBoundOperations = new List <string> {
"TestBoundOperation"
};
serviceConfig.ExcludedOperationImports = new List <string> {
"TestOperationImport"
};
serviceConfig.ExcludedSchemaTypes = new List <string> {
"TestSchemaType"
};
serviceConfig.GeneratedFileNamePrefix = "Test";
serviceConfig.GenerateMultipleFiles = true;
serviceConfig.IgnoreUnexpectedElementsAndAttributes = true;
serviceConfig.IncludeCustomHeaders = true;
serviceConfig.IncludeT4File = true;
serviceConfig.IncludeWebProxy = true;
serviceConfig.IncludeWebProxyNetworkCredentials = true;
serviceConfig.MakeTypesInternal = true;
serviceConfig.NamespacePrefix = "Test";
serviceConfig.OpenGeneratedFilesInIDE = true;
serviceConfig.ServiceName = "Test";
serviceConfig.UseDataServiceCollection = true;
serviceConfig.UseNamespacePrefix = true;
serviceConfig.WebProxyHost = "Test";
serviceConfig.WebProxyNetworkCredentialsDomain = "Test";
serviceConfig.WebProxyNetworkCredentialsPassword = "******";
serviceConfig.WebProxyNetworkCredentialsUsername = "******";
return(serviceConfig);
}
public void TestAddGeneratedClientCode_GeneratesAndSavesCodeFile()
{
var serviceName = "MyService";
ServiceConfiguration serviceConfig = new ServiceConfigurationV4()
{
MakeTypesInternal = true,
UseDataServiceCollection = false,
ServiceName = serviceName,
GeneratedFileNamePrefix = "MyFile",
IncludeT4File = false
};
var handlerHelper = new TestConnectedServiceHandlerHelper();
var codeGenDescriptor = SetupCodeGenDescriptor(serviceConfig, serviceName,
new TestODataT4CodeGeneratorFactory(), handlerHelper);
codeGenDescriptor.AddGeneratedClientCodeAsync().Wait();
using (var reader = new StreamReader(handlerHelper.AddedFileInputFileName))
{
var generatedCode = reader.ReadToEnd();
Assert.AreEqual("Generated code", generatedCode);
Assert.AreEqual(Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "MyFile.cs"),
handlerHelper.AddedFileTargetFilePath);
}
}
private async Task AddGeneratedCodeAsync(string metadata, string outputDirectory, LanguageOption languageOption, ServiceConfiguration serviceConfiguration)
{
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Generating Client Proxy for OData V4...");
ServiceConfigurationV4 servConfiguration = serviceConfiguration as ServiceConfigurationV4;
ODataT4CodeGenerator t4CodeGenerator = CodeGeneratorFactory.Create();
t4CodeGenerator.MetadataDocumentUri = metadata;
t4CodeGenerator.UseDataServiceCollection = servConfiguration.UseDataServiceCollection;
t4CodeGenerator.TargetLanguage =
languageOption == LanguageOption.GenerateCSharpCode
? ODataT4CodeGenerator.LanguageOption.CSharp
: ODataT4CodeGenerator.LanguageOption.VB;
t4CodeGenerator.IgnoreUnexpectedElementsAndAttributes = servConfiguration.IgnoreUnexpectedElementsAndAttributes;
t4CodeGenerator.EnableNamingAlias = servConfiguration.EnableNamingAlias;
t4CodeGenerator.NamespacePrefix = servConfiguration.NamespacePrefix;
t4CodeGenerator.MakeTypesInternal = servConfiguration.MakeTypesInternal;
t4CodeGenerator.GenerateMultipleFiles = servConfiguration.GenerateMultipleFiles;
t4CodeGenerator.ExcludedOperationImports = servConfiguration.ExcludedOperationImports;
t4CodeGenerator.ExcludedBoundOperations = servConfiguration.ExcludedBoundOperations;
t4CodeGenerator.ExcludedSchemaTypes = servConfiguration.ExcludedSchemaTypes;
var headers = new List <string>();
if (servConfiguration.CustomHttpHeaders != null)
{
var headerElements = servConfiguration.CustomHttpHeaders.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
foreach (var headerElement in headerElements)
{
// Trim header for empty spaces
var header = headerElement.Trim();
headers.Add(header);
}
}
t4CodeGenerator.CustomHttpHeaders = headers;
t4CodeGenerator.IncludeWebProxy = servConfiguration.IncludeWebProxy;
t4CodeGenerator.WebProxyHost = servConfiguration.WebProxyHost;
t4CodeGenerator.IncludeWebProxyNetworkCredentials = servConfiguration.IncludeWebProxyNetworkCredentials;
t4CodeGenerator.WebProxyNetworkCredentialsUsername = servConfiguration.WebProxyNetworkCredentialsUsername;
t4CodeGenerator.WebProxyNetworkCredentialsPassword = servConfiguration.WebProxyNetworkCredentialsPassword;
t4CodeGenerator.WebProxyNetworkCredentialsDomain = servConfiguration.WebProxyNetworkCredentialsDomain;
var tempFile = Path.GetTempFileName();
var referenceFolder = outputDirectory;
// Csdl file name is this format [ServiceName]Csdl.xml
var csdlFileName = string.Concat(servConfiguration.ServiceName, Common.Constants.CsdlFileNameSuffix);
var metadataFile = Path.Combine(referenceFolder, csdlFileName);
await FileHandler.AddFileAsync(tempFile, metadataFile, new ODataFileOptions { SuppressOverwritePrompt = true });
FileHandler.SetFileAsEmbeddedResource(csdlFileName);
t4CodeGenerator.EmitContainerPropertyAttribute = FileHandler.EmitContainerPropertyAttribute();
t4CodeGenerator.MetadataFilePath = metadataFile;
t4CodeGenerator.MetadataFileRelativePath = csdlFileName;
using (StreamWriter writer = File.CreateText(tempFile))
{
await writer.WriteAsync(t4CodeGenerator.TransformText());
await writer.FlushAsync();
if (t4CodeGenerator.Errors != null && t4CodeGenerator.Errors.Count > 0)
{
foreach (var err in t4CodeGenerator.Errors)
{
await MessageLogger.WriteMessageAsync(LogMessageCategory.Warning, err.ToString()).ConfigureAwait(false);
}
}
}
var outputFile = Path.Combine(referenceFolder, $"{this.GeneratedFileNamePrefix(servConfiguration.GeneratedFileNamePrefix)}{(languageOption == LanguageOption.GenerateCSharpCode ? ".cs" : ".vb")}");
await FileHandler.AddFileAsync(tempFile, outputFile, new ODataFileOptions { SuppressOverwritePrompt = true });
t4CodeGenerator.MultipleFilesManager?.GenerateFiles(servConfiguration.GenerateMultipleFiles, FileHandler, MessageLogger, referenceFolder, true, servConfiguration.OpenGeneratedFilesInIDE);
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Client Proxy for OData V4 was generated.");
}
public ODataConnectedServiceWizard(ConnectedServiceProviderContext context)
{
this.Context = context;
this.UserSettings = UserSettings.Load(context.Logger);
ConfigODataEndpointViewModel = new ConfigODataEndpointViewModel(this.UserSettings, this);
AdvancedSettingsViewModel = new AdvancedSettingsViewModel(this.UserSettings);
OperationImportsViewModel = new OperationImportsViewModel();
ServiceConfigurationV4 serviceConfig = null;
OperationImportsViewModel.PageEntering += ObjectSelectionViewModel_PageEntering;
if (this.Context.IsUpdating)
{
//Since ServiceConfigurationV4 is a derived type of ServiceConfiguration. So we can deserialize a ServiceConfiguration into a ServiceConfigurationV4.
serviceConfig = this.Context.GetExtendedDesignerData <ServiceConfigurationV4>();
ConfigODataEndpointViewModel.Endpoint = serviceConfig.Endpoint;
ConfigODataEndpointViewModel.EdmxVersion = serviceConfig.EdmxVersion;
ConfigODataEndpointViewModel.ServiceName = serviceConfig.ServiceName;
ConfigODataEndpointViewModel.CustomHttpHeaders = serviceConfig.CustomHttpHeaders;
// The ViewModel should always be filled otherwise if the wizard is completed without visiting this page the generated code becomes wrong
AdvancedSettingsViewModel.UseNamespacePrefix = serviceConfig.UseNamespacePrefix;
AdvancedSettingsViewModel.NamespacePrefix = serviceConfig.NamespacePrefix;
AdvancedSettingsViewModel.UseDataServiceCollection = serviceConfig.UseDataServiceCollection;
if (serviceConfig.EdmxVersion == Common.Constants.EdmxVersion4)
{
AdvancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes =
serviceConfig.IgnoreUnexpectedElementsAndAttributes;
AdvancedSettingsViewModel.EnableNamingAlias = serviceConfig.EnableNamingAlias;
AdvancedSettingsViewModel.IncludeT4File = serviceConfig.IncludeT4File;
AdvancedSettingsViewModel.MakeTypesInternal = serviceConfig.MakeTypesInternal;
}
ConfigODataEndpointViewModel.PageEntering += (sender, args) =>
{
var configOdataViewModel = sender as ConfigODataEndpointViewModel;
if (configOdataViewModel != null)
{
var configOdataView = configOdataViewModel.View as ConfigODataEndpoint;
configOdataView.Endpoint.IsEnabled = false;
configOdataView.OpenConnectedServiceJsonFileButton.IsEnabled = false;
configOdataView.OpenEndpointFileButton.IsEnabled = !serviceConfig.Endpoint.StartsWith("http");
configOdataView.ServiceName.IsEnabled = false;
configOdataViewModel.IncludeCustomHeaders = serviceConfig.IncludeCustomHeaders;
configOdataViewModel.IncludeWebProxy = serviceConfig.IncludeWebProxy;
configOdataViewModel.WebProxyHost = serviceConfig.WebProxyHost;
configOdataViewModel.IncludeWebProxyNetworkCredentials = serviceConfig.IncludeWebProxyNetworkCredentials;
configOdataViewModel.WebProxyNetworkCredentialsDomain = serviceConfig.WebProxyNetworkCredentialsDomain;
// don't accept any credentials from the restored settings
configOdataViewModel.WebProxyNetworkCredentialsUsername = null;
configOdataViewModel.WebProxyNetworkCredentialsPassword = null;
}
};
//Restore the advanced settings to UI elements.
AdvancedSettingsViewModel.PageEntering += (sender, args) =>
{
if (sender is AdvancedSettingsViewModel advancedSettingsViewModel)
{
if (advancedSettingsViewModel.View is AdvancedSettings advancedSettings)
{
advancedSettingsViewModel.GeneratedFileNamePrefix = serviceConfig.GeneratedFileNamePrefix;
advancedSettings.ReferenceFileName.IsEnabled = false;
advancedSettingsViewModel.UseNamespacePrefix = serviceConfig.UseNamespacePrefix;
advancedSettingsViewModel.NamespacePrefix = serviceConfig.NamespacePrefix;
advancedSettingsViewModel.UseDataServiceCollection = serviceConfig.UseDataServiceCollection;
advancedSettingsViewModel.GenerateMultipleFiles = serviceConfig.GenerateMultipleFiles;
advancedSettings.GenerateMultipleFiles.IsEnabled = false;
if (serviceConfig.EdmxVersion == Common.Constants.EdmxVersion4)
{
advancedSettingsViewModel.IgnoreUnexpectedElementsAndAttributes = serviceConfig.IgnoreUnexpectedElementsAndAttributes;
advancedSettingsViewModel.EnableNamingAlias = serviceConfig.EnableNamingAlias;
advancedSettingsViewModel.IncludeT4File = serviceConfig.IncludeT4File;
advancedSettingsViewModel.MakeTypesInternal = serviceConfig.MakeTypesInternal;
advancedSettings.IncludeT4File.IsEnabled = false;
}
}
}
};
}
this.Pages.Add(ConfigODataEndpointViewModel);
this.Pages.Add(OperationImportsViewModel);
this.Pages.Add(AdvancedSettingsViewModel);
this.IsFinishEnabled = true;
}
public void TestAddGeneratedClientCode_GeneratesT4Templates_AllSettingsSet()
{
var serviceName = "MyService";
ServiceConfiguration serviceConfig = new ServiceConfigurationV4()
{
EdmxVersion = Common.Constants.EdmxVersion4,
ServiceName = serviceName,
IncludeT4File = true,
Endpoint = "https://service/$metadata",
IncludeCustomHeaders = true,
CustomHttpHeaders = "Key1:val\nKey2:val2",
IncludeWebProxy = true,
WebProxyHost = "http://localhost:8080",
IncludeWebProxyNetworkCredentials = true,
WebProxyNetworkCredentialsDomain = "domain",
WebProxyNetworkCredentialsUsername = "******",
WebProxyNetworkCredentialsPassword = "******",
ExcludedSchemaTypes = new List <string>()
{
"Namespace.Type1", "Namespace.Type2", "Namespace.Type3"
},
ExcludedOperationImports = new List <string>()
{
"Operation1", "Operation2"
},
GeneratedFileNamePrefix = "Reference",
UseNamespacePrefix = true,
UseDataServiceCollection = true,
NamespacePrefix = "MyNamespace",
EnableNamingAlias = true,
GenerateMultipleFiles = true,
MakeTypesInternal = true,
IgnoreUnexpectedElementsAndAttributes = true,
OpenGeneratedFilesInIDE = true
};
var codeGenFactory = new TestODataT4CodeGeneratorFactory();
var handlerHelper = new TestConnectedServiceHandlerHelper();
var codeGenDescriptor = SetupCodeGenDescriptor(serviceConfig, serviceName, codeGenFactory, handlerHelper);
codeGenDescriptor.AddGeneratedClientCodeAsync().Wait();
var ttIncludeSourcePath = Path.Combine(Directory.GetCurrentDirectory(), "Templates", "ODataT4CodeGenerator.ttinclude");
var ttIncludeOutputPath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "Reference.ttinclude");
var fileManagerSourcePath = Path.Combine(Directory.GetCurrentDirectory(), "Templates", "ODataT4CodeGenFilesManager.ttinclude");
var fileManagerOutputPath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "ODataT4CodeGenFilesManager.ttinclude");
var ttOutputPath = Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "Reference.tt");
Assert.IsTrue(handlerHelper.AddedFiles.Contains((fileManagerOutputPath, fileManagerSourcePath)));
var ttInclude = handlerHelper.AddedFiles.FirstOrDefault(f => f.CreatedFile == ttIncludeOutputPath);
Assert.IsNotNull(ttInclude);
var ttIncludeOriginalText = File.ReadAllText(ttIncludeSourcePath);
var ttIncludeSavedText = File.ReadAllText(ttInclude.SourceFile);
Assert.AreEqual(ttIncludeOriginalText, ttIncludeSavedText);
var tt = handlerHelper.AddedFiles.FirstOrDefault(f => f.CreatedFile == ttOutputPath);
Assert.IsNotNull(tt);
var ttExpectedText = File.ReadAllText(Path.Combine(Directory.GetCurrentDirectory(), "CodeGeneration", "TestConfigAllOptionsSet.txt"));
ttExpectedText = ttExpectedText.Replace("$$CsdlFullPath$$", Path.Combine(TestProjectRootPath, ServicesRootFolder, serviceName, "Csdl.xml"));
var ttSavedText = File.ReadAllText(tt.SourceFile);
Assert.AreEqual(ttExpectedText, ttSavedText);
}
public override void SetExtendedDesignerData <TData>(TData data)
{
savedData = data as ServiceConfigurationV4;
}
/// <summary>
/// Create the service configuration according to the edmx version.
/// </summary>
/// <returns>If the edm version is less than 4.0, returns a ServiceConfiguration, else, returns ServiceConfigurationV4</returns>
private ServiceConfiguration CreateServiceConfiguration()
{
ServiceConfiguration serviceConfiguration;
if (ConfigODataEndpointViewModel.EdmxVersion == Common.Constants.EdmxVersion4)
{
serviceConfiguration = new ServiceConfigurationV4
{
IgnoreUnexpectedElementsAndAttributes =
AdvancedSettingsViewModel.UserSettings.IgnoreUnexpectedElementsAndAttributes,
GenerateDynamicPropertiesCollection = AdvancedSettingsViewModel.UserSettings.GenerateDynamicPropertiesCollection,
DynamicPropertiesCollectionName = AdvancedSettingsViewModel.UserSettings.DynamicPropertiesCollectionName,
EnableNamingAlias = AdvancedSettingsViewModel.UserSettings.EnableNamingAlias,
IncludeT4File = AdvancedSettingsViewModel.UserSettings.IncludeT4File,
MakeTypesInternal = AdvancedSettingsViewModel.UserSettings.MakeTypesInternal
};
}
else
{
serviceConfiguration = new ServiceConfigurationV3
{
IncludeExtensionsT4File = AdvancedSettingsViewModel.UserSettings.IncludeExtensionsT4File,
OperationImportsGenerator = AdvancedSettingsViewModel.UserSettings.OperationImportsGenerator,
GenerateOperationImports = AdvancedSettingsViewModel.UserSettings.SelectOperationImports,
FunctionImports = FunctionImportsViewModel.FunctionImports
};
}
serviceConfiguration.LanguageOption = ConfigODataEndpointViewModel.UserSettings.LanguageOption;
serviceConfiguration.ServiceName = ConfigODataEndpointViewModel.UserSettings.ServiceName;
serviceConfiguration.AcceptAllUntrustedCertificates = ConfigODataEndpointViewModel.UserSettings.AcceptAllUntrustedCertificates;
serviceConfiguration.Endpoint = ConfigODataEndpointViewModel.UserSettings.Endpoint;
serviceConfiguration.EdmxVersion = ConfigODataEndpointViewModel.EdmxVersion;
serviceConfiguration.UseDataServiceCollection = AdvancedSettingsViewModel.UserSettings.UseDataServiceCollection;
serviceConfiguration.UseAsyncDataServiceCollection = AdvancedSettingsViewModel.UserSettings.UseAsyncDataServiceCollection;
serviceConfiguration.GeneratedFileNamePrefix = AdvancedSettingsViewModel.UserSettings.GeneratedFileNamePrefix;
serviceConfiguration.UseNameSpacePrefix = AdvancedSettingsViewModel.UserSettings.UseNameSpacePrefix;
serviceConfiguration.OpenGeneratedFilesOnComplete = ConfigODataEndpointViewModel.UserSettings.OpenGeneratedFilesOnComplete;
if (AdvancedSettingsViewModel.UserSettings.UseNameSpacePrefix && !string.IsNullOrEmpty(AdvancedSettingsViewModel.UserSettings.NamespacePrefix))
{
serviceConfiguration.NamespacePrefix = AdvancedSettingsViewModel.UserSettings.NamespacePrefix;
}
serviceConfiguration.ExcludedOperationImportsNames = AdvancedSettingsViewModel.UserSettings.ExcludedOperationImportsNames;
serviceConfiguration.OperationImports = FunctionImportsViewModel.OperationImports;
#region Network Credentials
serviceConfiguration.UseNetworkCredentials =
ConfigODataEndpointViewModel.UseNetworkCredentials;
serviceConfiguration.NetworkCredentialsUserName =
ConfigODataEndpointViewModel.NetworkCredentialsUserName;
serviceConfiguration.NetworkCredentialsPassword =
ConfigODataEndpointViewModel.NetworkCredentialsPassword;
serviceConfiguration.NetworkCredentialsDomain =
ConfigODataEndpointViewModel.NetworkCredentialsDomain;
#endregion
#region Web-proxy
serviceConfiguration.UseWebProxy =
ConfigODataEndpointViewModel.UseWebProxy;
serviceConfiguration.UseWebProxyCredentials =
ConfigODataEndpointViewModel.UseWebProxyCredentials;
serviceConfiguration.WebProxyNetworkCredentialsUserName =
ConfigODataEndpointViewModel.WebProxyNetworkCredentialsUserName;
serviceConfiguration.WebProxyNetworkCredentialsPassword =
ConfigODataEndpointViewModel.WebProxyNetworkCredentialsPassword;
serviceConfiguration.WebProxyNetworkCredentialsDomain =
ConfigODataEndpointViewModel.WebProxyNetworkCredentialsDomain;
serviceConfiguration.WebProxyUri =
ConfigODataEndpointViewModel.WebProxyUri;
#endregion
return(serviceConfiguration);
}
private async Task AddT4FileAsync(string metadata, string outputDirectory, LanguageOption languageOption, ServiceConfigurationV4 serviceConfiguration)
{
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "Adding T4 files for OData V4...");
var t4IncludeTempFile = Path.GetTempFileName();
var t4Folder = Path.Combine(this.CurrentAssemblyPath, "Templates");
var referenceFolder = outputDirectory;
// generate .ttinclude
using (StreamWriter writer = File.CreateText(t4IncludeTempFile))
{
var ttIncludeText = File.ReadAllText(Path.Combine(t4Folder, "ODataT4CodeGenerator.ttinclude"));
if (languageOption == LanguageOption.GenerateVBCode)
{
ttIncludeText = Regex.Replace(ttIncludeText, "(output extension=)\".cs\"", "$1\".vb\"");
}
await writer.WriteAsync(ttIncludeText);
await writer.FlushAsync();
}
await FileHandler.AddFileAsync(t4IncludeTempFile, Path.Combine(referenceFolder, this.GeneratedFileNamePrefix(serviceConfiguration.GeneratedFileNamePrefix) + ".ttinclude"));
await FileHandler.AddFileAsync(Path.Combine(t4Folder, "ODataT4CodeGenFilesManager.ttinclude"), Path.Combine(referenceFolder, "ODataT4CodeGenFilesManager.ttinclude"));
var csdlTempFile = Path.GetTempFileName();
// Csdl file name is this format [ServiceName]Csdl.xml
var csdlFileName = string.Concat(serviceConfiguration.ServiceName, Common.Constants.CsdlFileNameSuffix);
var metadataFile = Path.Combine(referenceFolder, csdlFileName);
// When the T4 file is added to the target project, the proxy and metadata files
// are not automatically generated. To avoid ending up with an empty metadata file with
// warnings, we pre-populate it with the root element. The content will later be overwritten with the actual metadata when T4 template is run by the user.
using (StreamWriter writer = File.CreateText(csdlTempFile))
{
await writer.WriteLineAsync("<edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\">");
await writer.WriteLineAsync("</edmx:Edmx>");
}
await FileHandler.AddFileAsync(csdlTempFile, metadataFile, new ODataFileOptions { SuppressOverwritePrompt = true });
FileHandler.SetFileAsEmbeddedResource(csdlFileName);
var t4TempFile = Path.GetTempFileName();
using (StreamWriter writer = File.CreateText(t4TempFile))
{
var text = File.ReadAllText(Path.Combine(t4Folder, "ODataT4CodeGenerator.tt"));
text = Regex.Replace(text, "ODataT4CodeGenerator(\\.ttinclude)", this.GeneratedFileNamePrefix(serviceConfiguration.GeneratedFileNamePrefix) + "$1");
text = Regex.Replace(text, "(public const string MetadataDocumentUri = )\"\";", "$1@\"" + serviceConfiguration.Endpoint + "\";");
text = Regex.Replace(text, "(public const bool UseDataServiceCollection = ).*;", "$1" + serviceConfiguration.UseDataServiceCollection.ToString(CultureInfo.InvariantCulture).ToLower(CultureInfo.InvariantCulture) + ";");
text = Regex.Replace(text, "(public const string NamespacePrefix = )\"\\$rootnamespace\\$\";", "$1\"" + serviceConfiguration.NamespacePrefix + "\";");
if (languageOption == LanguageOption.GenerateCSharpCode)
{
text = Regex.Replace(text, "(public const string TargetLanguage = )\"OutputLanguage\";",
"$1\"CSharp\";");
}
else if (languageOption == LanguageOption.GenerateVBCode)
{
text = Regex.Replace(text, "(public const string TargetLanguage = )\"OutputLanguage\";",
"$1\"VB\";");
}
text = Regex.Replace(text, "(public const bool EnableNamingAlias = )true;", "$1" + serviceConfiguration.EnableNamingAlias.ToString(CultureInfo.InvariantCulture).ToLower(CultureInfo.InvariantCulture) + ";");
text = Regex.Replace(text, "(public const bool IgnoreUnexpectedElementsAndAttributes = )true;", "$1" + serviceConfiguration.IgnoreUnexpectedElementsAndAttributes.ToString(CultureInfo.InvariantCulture).ToLower(CultureInfo.InvariantCulture) + ";");
text = Regex.Replace(text, "(public const bool MakeTypesInternal = )false;", "$1" + serviceConfiguration.MakeTypesInternal.ToString(CultureInfo.InvariantCulture).ToLower(CultureInfo.InvariantCulture) + ";");
text = Regex.Replace(text, "(public const bool GenerateMultipleFiles = )false;", "$1" + serviceConfiguration.GenerateMultipleFiles.ToString(CultureInfo.InvariantCulture).ToLower(CultureInfo.InvariantCulture) + ";");
var customHeaders = serviceConfiguration.CustomHttpHeaders ?? "";
text = Regex.Replace(text, "(public const string CustomHttpHeaders = )\"\";", "$1@\"" + customHeaders + "\";");
text = Regex.Replace(text, "(public const string MetadataFilePath = )\"\";", "$1@\"" + metadataFile + "\";");
text = Regex.Replace(text, "(public const string MetadataFileRelativePath = )\"\";", "$1@\"" + csdlFileName + "\";");
if (serviceConfiguration.ExcludedOperationImports?.Any() == true)
{
text = Regex.Replace(text, "(public const string ExcludedOperationImports = )\"\";", "$1\"" + string.Join(",", serviceConfiguration.ExcludedOperationImports) + "\";");
}
if (serviceConfiguration.ExcludedBoundOperations?.Any() == true)
{
text = Regex.Replace(text, "(public const string ExcludedBoundOperations = )\"\";", "$1\"" + string.Join(",", serviceConfiguration.ExcludedBoundOperations) + "\";");
}
if (serviceConfiguration.ExcludedSchemaTypes?.Any() == true)
{
text = Regex.Replace(text, "(public const string ExcludedSchemaTypes = )\"\";", "$1\"" + string.Join(",", serviceConfiguration.ExcludedSchemaTypes) + "\";");
}
await writer.WriteAsync(text);
await writer.FlushAsync();
}
await FileHandler.AddFileAsync(t4TempFile, Path.Combine(referenceFolder, this.GeneratedFileNamePrefix(serviceConfiguration.GeneratedFileNamePrefix) + ".tt"));
await MessageLogger.WriteMessageAsync(LogMessageCategory.Information, "T4 files for OData V4 were added.");
}
