public static IApplicationBuilder UseODataMigration(
     this IApplicationBuilder builder,
     string v3Edmx,
     Edm.IEdmModel v4Model)
 {
     return(builder
            .UseMiddleware <ODataMigrationMiddleware>(v3Edmx, v4Model)
            .UseRouter((new RouteBuilder(builder)).MapGet("$metadata", async(context) =>
     {
         await context.Response.WriteAsync(v3Edmx);
     })
                       .Build()));
 }
        public static IApplicationBuilder UseODataMigration(this IApplicationBuilder builder,
                                                            Data.Edm.IEdmModel v3model,
                                                            Edm.IEdmModel v4Model)
        {
            // Convert v3 model to string to pass through metadata request.
            string v3Edmx;

            using (StringWriter stringWriter = new StringWriter())
            {
                using (XmlWriter xmlWriter = XmlWriter.Create(stringWriter))
                {
                    IEnumerable <Data.Edm.Validation.EdmError> errors = new List <Data.Edm.Validation.EdmError>();
                    Data.Edm.Csdl.EdmxWriter.TryWriteEdmx(v3model, xmlWriter, Data.Edm.Csdl.EdmxTarget.OData, out errors);
                }

                v3Edmx = stringWriter.ToString();
            }

            return(builder.UseODataMigration(v3Edmx, v4Model));
        }
Beispiel #3
0
        private void OpenConnectedServiceJsonFileButton_Click(object sender, RoutedEventArgs e)
        {
            var fileDialogTitle = "Open OData Connected Service Config File";

            var openFileDialog = new Win32.OpenFileDialog
            {
                DefaultExt = ".json",
                Filter     = "JSON File (.json)|*.json",
                Title      = fileDialogTitle
            };

            if (!(openFileDialog.ShowDialog() == true)) // Result of ShowDialog() call is bool?
            {
                return;
            }

            if (!File.Exists(openFileDialog.FileName))
            {
                MessageBox.Show(
                    $"File \"{openFileDialog.FileName}\" does not exists.",
                    string.Format(CultureInfo.InvariantCulture, fileDialogTitle),
                    MessageBoxButton.OK,
                    MessageBoxImage.Warning);
                return;
            }

            var jsonFileText = File.ReadAllText(openFileDialog.FileName);

            if (string.IsNullOrWhiteSpace(jsonFileText))
            {
                MessageBox.Show("Config file is empty.",
                                string.Format(CultureInfo.InvariantCulture, fileDialogTitle),
                                MessageBoxButton.OK,
                                MessageBoxImage.Warning);
                return;
            }

            ConnectedServiceJsonFileData connectedServiceData;

            try
            {
                connectedServiceData = JsonConvert.DeserializeObject <ConnectedServiceJsonFileData>(jsonFileText);
            }
            catch (JsonException ex)
            {
                System.Diagnostics.Debug.Assert(ex != null);
                MessageBox.Show(
                    "Contents of the config file could not be deserialized.",
                    string.Format(CultureInfo.InvariantCulture, fileDialogTitle),
                    MessageBoxButton.OK,
                    MessageBoxImage.Warning);
                return;
            }

            // connectedServiceData not expected to be null at this point
            if (connectedServiceData.ExtendedData != null)
            {
                this.UserSettings.CopyPropertiesFrom(connectedServiceData.ExtendedData);
            }

            ODataConnectedServiceWizard connectedServiceWizard = GetODataConnectedServiceWizard();

            // get Operation Imports and bound operations from metadata for excluding ExcludedOperationImports and ExcludedBoundOperations
            try
            {
                connectedServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath = connectedServiceWizard.ConfigODataEndpointViewModel.GetMetadata(out var version);
                connectedServiceWizard.ConfigODataEndpointViewModel.EdmxVersion      = version;
                if (version == Constants.EdmxVersion4)
                {
                    Edm.IEdmModel model = EdmHelper.GetEdmModelFromFile(connectedServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath);

                    IEnumerable <Edm.IEdmSchemaType> entityTypes = EdmHelper.GetSchemaTypes(model);
                    IDictionary <Edm.IEdmType, List <Edm.IEdmOperation> > boundOperations = EdmHelper.GetBoundOperations(model);
                    connectedServiceWizard.SchemaTypesViewModel.LoadSchemaTypes(entityTypes, boundOperations);
                    connectedServiceWizard.ProcessedEndpointForSchemaTypes = this.UserSettings.Endpoint;
                    connectedServiceWizard.SchemaTypesViewModel.LoadFromUserSettings();

                    IEnumerable <Edm.IEdmOperationImport> operations = EdmHelper.GetOperationImports(model);
                    connectedServiceWizard.OperationImportsViewModel.LoadOperationImports(operations, new HashSet <string>(), new Dictionary <string, SchemaTypeModel>());
                    connectedServiceWizard.ProcessedEndpointForOperationImports = this.UserSettings.Endpoint;
                    connectedServiceWizard.OperationImportsViewModel.LoadFromUserSettings();
                }
            }
            catch
            {
                // ignored
            }
        }
Beispiel #4
0
        private void OpenConnectedServiceJsonFileButton_Click(object sender, RoutedEventArgs e)
        {
            var openFileDialog = new Microsoft.Win32.OpenFileDialog
            {
                DefaultExt = ".json",
                Filter     = "JSON File (.json)|*.json",
                Title      = "Open OData Connected Service Config File"
            };

            var result = openFileDialog.ShowDialog();

            if (result == false)
            {
                return;
            }
            if (!File.Exists(openFileDialog.FileName))
            {
                MessageBox.Show($"File \"{openFileDialog.FileName}\" does not exists.", string.Format(CultureInfo.InvariantCulture, "Open OData Connected Service json-file"), MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }

            var jsonFileText = File.ReadAllText(openFileDialog.FileName);

            if (string.IsNullOrWhiteSpace(jsonFileText))
            {
                MessageBox.Show("File have not content.", string.Format(CultureInfo.InvariantCulture, "Open OData Connected Service json-file"), MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }
            if (JObject.Parse(jsonFileText) == null)
            {
                MessageBox.Show("Can't convert file content to JObject.", string.Format(CultureInfo.InvariantCulture, "Open OData Connected Service json-file"), MessageBoxButton.OK, MessageBoxImage.Warning);
                return;
            }
            var microsoftConnectedServiceData = JsonConvert.DeserializeObject <ConnectedServiceJsonFileData>(jsonFileText);

            if (microsoftConnectedServiceData != null)
            {
                this.UserSettings                          = new UserSettings();
                this.UserSettings.Endpoint                 = microsoftConnectedServiceData.ExtendedData?.Endpoint ?? this.UserSettings.Endpoint;
                this.UserSettings.ServiceName              = microsoftConnectedServiceData.ExtendedData?.ServiceName ?? this.UserSettings.ServiceName;
                this.UserSettings.GeneratedFileNamePrefix  = microsoftConnectedServiceData.ExtendedData?.GeneratedFileNamePrefix ?? this.UserSettings.GeneratedFileNamePrefix;
                this.UserSettings.OpenGeneratedFilesInIDE  = microsoftConnectedServiceData.ExtendedData?.OpenGeneratedFilesInIDE ?? this.UserSettings.OpenGeneratedFilesInIDE;
                this.UserSettings.MakeTypesInternal        = microsoftConnectedServiceData.ExtendedData?.MakeTypesInternal ?? this.UserSettings.MakeTypesInternal;
                this.UserSettings.NamespacePrefix          = microsoftConnectedServiceData.ExtendedData?.NamespacePrefix ?? this.UserSettings.NamespacePrefix;
                this.UserSettings.UseDataServiceCollection = microsoftConnectedServiceData.ExtendedData?.UseDataServiceCollection ?? this.UserSettings.UseDataServiceCollection;
                this.UserSettings.UseNamespacePrefix       = microsoftConnectedServiceData.ExtendedData?.UseNamespacePrefix ?? this.UserSettings.UseNamespacePrefix;
                this.UserSettings.IncludeT4File            = microsoftConnectedServiceData.ExtendedData?.IncludeT4File ?? this.UserSettings.IncludeT4File;
                this.UserSettings.IgnoreUnexpectedElementsAndAttributes = microsoftConnectedServiceData.ExtendedData?.IgnoreUnexpectedElementsAndAttributes ?? this.UserSettings.IgnoreUnexpectedElementsAndAttributes;
                this.UserSettings.GenerateMultipleFiles              = microsoftConnectedServiceData.ExtendedData?.GenerateMultipleFiles ?? this.UserSettings.GenerateMultipleFiles;
                this.UserSettings.EnableNamingAlias                  = microsoftConnectedServiceData.ExtendedData?.EnableNamingAlias ?? this.UserSettings.EnableNamingAlias;
                this.UserSettings.CustomHttpHeaders                  = microsoftConnectedServiceData.ExtendedData?.CustomHttpHeaders ?? this.UserSettings.CustomHttpHeaders;
                this.UserSettings.IncludeCustomHeaders               = microsoftConnectedServiceData.ExtendedData?.IncludeCustomHeaders ?? this.UserSettings.IncludeCustomHeaders;
                this.UserSettings.ExcludedOperationImports           = microsoftConnectedServiceData.ExtendedData?.ExcludedOperationImports ?? new List <string>();
                this.UserSettings.ExcludedBoundOperations            = microsoftConnectedServiceData.ExtendedData?.ExcludedBoundOperations ?? new List <string>();
                this.UserSettings.ExcludedSchemaTypes                = microsoftConnectedServiceData.ExtendedData?.ExcludedSchemaTypes ?? new List <string>();
                this.UserSettings.WebProxyHost                       = microsoftConnectedServiceData.ExtendedData?.WebProxyHost ?? this.UserSettings.WebProxyHost;
                this.UserSettings.IncludeWebProxy                    = microsoftConnectedServiceData.ExtendedData?.IncludeWebProxy ?? this.UserSettings.IncludeWebProxy;
                this.UserSettings.IncludeWebProxyNetworkCredentials  = microsoftConnectedServiceData.ExtendedData?.IncludeWebProxyNetworkCredentials ?? this.UserSettings.IncludeWebProxyNetworkCredentials;
                this.UserSettings.WebProxyNetworkCredentialsDomain   = microsoftConnectedServiceData.ExtendedData?.WebProxyNetworkCredentialsDomain ?? this.UserSettings.WebProxyNetworkCredentialsDomain;
                this.UserSettings.WebProxyNetworkCredentialsPassword = microsoftConnectedServiceData.ExtendedData?.WebProxyNetworkCredentialsPassword ?? this.UserSettings.WebProxyNetworkCredentialsPassword;
                this.UserSettings.WebProxyNetworkCredentialsUsername = microsoftConnectedServiceData.ExtendedData?.WebProxyNetworkCredentialsUsername ?? this.UserSettings.WebProxyNetworkCredentialsUsername;
                ODataConnectedServiceWizard ServiceWizard = ((ConfigODataEndpointViewModel)this.DataContext).ServiceWizard;
                this.UserSettings.MruEndpoints = UserSettings.Load(ServiceWizard.Context.Logger)?.MruEndpoints;

                ServiceWizard.ConfigODataEndpointViewModel.UserSettings = this.UserSettings;
                ServiceWizard.ConfigODataEndpointViewModel.LoadFromUserSettings();

                ServiceWizard.AdvancedSettingsViewModel.UserSettings = this.UserSettings;
                ServiceWizard.AdvancedSettingsViewModel.LoadFromUserSettings();

                ServiceWizard.OperationImportsViewModel.UserSettings = this.UserSettings;

                // get Operation Imports and bound operations from metadata for excluding ExcludedOperationImports and ExcludedBoundOperations
                try
                {
                    ServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath = ServiceWizard.ConfigODataEndpointViewModel.GetMetadata(out var version);
                    ServiceWizard.ConfigODataEndpointViewModel.EdmxVersion      = version;
                    if (version == Constants.EdmxVersion4)
                    {
                        Edm.IEdmModel model = EdmHelper.GetEdmModelFromFile(ServiceWizard.ConfigODataEndpointViewModel.MetadataTempPath);

                        IEnumerable <Edm.IEdmSchemaType> entityTypes = EdmHelper.GetSchemaTypes(model);
                        IDictionary <Edm.IEdmType, List <Edm.IEdmOperation> > boundOperations = EdmHelper.GetBoundOperations(model);
                        ServiceWizard.SchemaTypesViewModel.LoadSchemaTypes(entityTypes, boundOperations);
                        ServiceWizard.ProcessedEndpointForSchemaTypes = this.UserSettings.Endpoint;
                        ServiceWizard.SchemaTypesViewModel.LoadFromUserSettings();

                        IEnumerable <Edm.IEdmOperationImport> operations = EdmHelper.GetOperationImports(model);
                        ServiceWizard.OperationImportsViewModel.LoadOperationImports(operations, new HashSet <string>(), new Dictionary <string, SchemaTypeModel>());
                        ServiceWizard.ProcessedEndpointForOperationImports = this.UserSettings.Endpoint;
                        ServiceWizard.OperationImportsViewModel.LoadFromUserSettings();

                        //IDictionary<Edm.IEdmType, List<Edm.IEdmOperation>> allBoundOperations = EdmHelper.GetBoundOperations(model);
                        //ServiceWizard.BoundOperationsViewModel.LoadBoundOperations(allBoundOperations,
                        //    new HashSet<string>(), new Dictionary<string, SchemaTypeModel>());
                        //ServiceWizard.ProcessedEndpointForBoundOperations = this.UserSettings.Endpoint;
                        //ServiceWizard.BoundOperationsViewModel.LoadFromUserSettings();
                    }
                }
                catch
                {
                    // ignored
                }
            }
        }