private static EntityDesignNewFunctionImportResult ShowNewFunctionImportDialog( Function selectedSproc, string selectedSprocName, StorageEntityModel sModel, ConceptualEntityModel cModel, ConceptualEntityContainer cContainer, string dialogTitle, Object selectedObject) { using (var dialog = new NewFunctionImportDialog( selectedSproc, selectedSprocName, sModel.Functions(), cModel.ComplexTypes(), cModel.EntityTypes(), cContainer, selectedObject)) { dialog.Text = dialogTitle; var dialogResult = dialog.ShowDialog(); var result = new EntityDesignNewFunctionImportResult { DialogResult = dialogResult, Function = dialog.Function, FunctionName = dialog.FunctionImportName, IsComposable = dialog.IsComposable, ReturnType = dialog.ReturnType, Schema = dialog.Schema }; return(result); } }
internal static void ValidateConceptualEntityContainer(ConceptualEntityContainer conceptualEntityContainer) { ValidateEFElement(conceptualEntityContainer); var conceptualModel = conceptualEntityContainer.Parent as BaseEntityModel; Debug.Assert(conceptualModel != null, "The ConceptualEntityContainer sent must be in a BaseEntityModel"); Debug.Assert(conceptualModel.IsCSDL, "The ConceptualEntityContainer sent must be passed in from the conceptual model"); }
/// <summary> /// Creates a FunctionImport element that mimics the nodes under the Function element. /// </summary> /// <param name="function"></param> internal CreateFunctionImportCommand(ConceptualEntityContainer ec, Function function, string functionImportName, object returnType) { CommandValidation.ValidateConceptualEntityContainer(ec); CommandValidation.ValidateFunction(function); Container = ec; Function = function; FunctionImportName = functionImportName; ReturnSingleType = returnType; }
/// <summary> /// Create a Function Import whose return type being created in passed in CreateComplexTypeCommand. /// </summary> /// <param name="ec"></param> /// <param name="function"></param> /// <param name="functionImportName"></param> /// <param name="prereqCommand"></param> internal CreateFunctionImportCommand( ConceptualEntityContainer ec, Function function, string functionImportName, CreateComplexTypeCommand prereqCommand) { ValidatePrereqCommand(prereqCommand); CommandValidation.ValidateConceptualEntityContainer(ec); CommandValidation.ValidateFunction(function); Container = ec; Function = function; FunctionImportName = functionImportName; AddPreReqCommand(prereqCommand); }
/// <summary> /// Change various aspects of the passed in Function Import. The passed in function import will be modified based on the /// other passed-in parameters (null is not ignored). /// </summary> /// <param name="fi"></param> /// <param name="function"></param> /// <param name="functionImportName"></param> /// <param name="returnType">Object of type EntityType or string representing the primitive type/'None'</param> internal ChangeFunctionImportCommand( ConceptualEntityContainer ec, FunctionImport fi, Function function, string functionImportName, BoolOrNone functionImportIsComposable, bool changeReturnType, object returnType) { CommandValidation.ValidateFunctionImport(fi); ValidateString(functionImportName); FunctionImport = fi; Function = function; EntityContainer = ec; FunctionImportName = functionImportName; FunctionImportIsComposable = functionImportIsComposable; ChangeReturnType = changeReturnType; ReturnSingleType = returnType; _efContainerToBeNormalized = new List <EFContainer>(); }
/// <summary> /// Change various aspects of the passed in Function Import. The passed in function import will be modified based on the /// other passed-in parameters (null is not ignored). /// </summary> /// <param name="ec"></param> /// <param name="fi"></param> /// <param name="function"></param> /// <param name="functionImportName"></param> /// <param name="prereqCommand"></param> internal ChangeFunctionImportCommand( ConceptualEntityContainer ec, FunctionImport fi, Function function, string functionImportName, BoolOrNone functionImportIsComposable, CreateComplexTypeCommand prereqCommand) { ValidatePrereqCommand(prereqCommand); CommandValidation.ValidateFunctionImport(fi); ValidateString(functionImportName); FunctionImport = fi; Function = function; EntityContainer = ec; FunctionImportName = functionImportName; FunctionImportIsComposable = functionImportIsComposable; ChangeReturnType = true; _efContainerToBeNormalized = new List <EFContainer>(); AddPreReqCommand(prereqCommand); }
internal static FunctionImport CreateFunctionImport( EditingContext editingContext, EFArtifact artifact, Function selectedSproc, StorageEntityModel sModel, ConceptualEntityModel cModel, ConceptualEntityContainer cContainer, EntityType entityType, string originatingId) { FunctionImport functionImportResult = null; Debug.Assert(editingContext != null, "editingContext should not be null"); Debug.Assert(artifact != null, "artifact should not be null"); Debug.Assert(!string.IsNullOrEmpty(originatingId), "originatingId should not be null or empty"); // show dialog appropriate to framework version var result = ShowNewFunctionImportDialog( selectedSproc, null /* selectedSprocName Parameter */, sModel, cModel, cContainer, DialogsResource.NewFunctionImportDialog_AddFunctionImportTitle, entityType); // if user selected OK on the dialog then create the FunctionImport if (DialogResult.OK == result.DialogResult) { var commands = new Collection <Command>(); CreateComplexTypeCommand createComplexTypeCommand = null; // Make the decision based on what is returned by the dialog. // If return type is a string and result schema is not null, that means the user would like create a new complex type for the function import return. if (result.ReturnType is string && result.Schema != null) { createComplexTypeCommand = CreateMatchingFunctionImportCommand.AddCreateComplexTypeCommands( sModel, result.ReturnType as string, result.Schema.RawColumns, commands); } // If ReturnType is a complex type and result schema is not null, the complex type needs to be updated to be in sync with schema columns. else if (result.ReturnType is ComplexType && result.Schema != null) { var complexType = result.ReturnType as ComplexType; var propertiesDictionary = complexType.Properties().ToDictionary(p => p.LocalName.Value); CreateMatchingFunctionImportCommand.AddChangeComplexTypePropertiesCommands( complexType, propertiesDictionary, result.Schema.RawColumns, commands); } CreateFunctionImportCommand cmdFuncImp; if (createComplexTypeCommand == null) { cmdFuncImp = new CreateFunctionImportCommand(cContainer, result.Function, result.FunctionName, result.ReturnType); } else { // Pass in the pre-req command to create complex type to the command. cmdFuncImp = new CreateFunctionImportCommand(cContainer, result.Function, result.FunctionName, createComplexTypeCommand); } commands.Add(cmdFuncImp); // now add a FunctionImport and a FunctionImportMapping (if appropriate) if (artifact.MappingModel() != null && artifact.MappingModel().FirstEntityContainerMapping != null) { var cmdFuncImpMapping = new CreateFunctionImportMappingCommand( artifact.MappingModel().FirstEntityContainerMapping, result.Function, cmdFuncImp.Id); cmdFuncImpMapping.AddPreReqCommand(cmdFuncImp); commands.Add(cmdFuncImpMapping); IDictionary <string, string> mapPropertyNameToColumnName = null; if (result.Schema != null) { mapPropertyNameToColumnName = ModelHelper.ConstructComplexTypePropertyNameToColumnNameMapping( result.Schema.Columns.Select(c => c.Name).ToList()); } // Create explicit function-import result type mapping if the return type is a complex type. if (createComplexTypeCommand != null) { commands.Add( new CreateFunctionImportTypeMappingCommand(cmdFuncImpMapping, createComplexTypeCommand) { CreateDefaultScalarProperties = true, PropertyNameToColumnNameMap = mapPropertyNameToColumnName }); } else if (result.ReturnType is ComplexType) { commands.Add( new CreateFunctionImportTypeMappingCommand(cmdFuncImpMapping, result.ReturnType as ComplexType) { CreateDefaultScalarProperties = true, PropertyNameToColumnNameMap = mapPropertyNameToColumnName }); } } var cp = new CommandProcessor(editingContext, originatingId, Resources.Tx_CreateFunctionImport, commands); cp.Invoke(); functionImportResult = cmdFuncImp.FunctionImport; NavigateToFunction(functionImportResult); } return(functionImportResult); }
internal static void EditFunctionImport( EditingContext editingContext, FunctionImport functionImport, StorageEntityModel sModel, ConceptualEntityModel cModel, ConceptualEntityContainer cContainer, object selectedObject, string originatingId) { Debug.Assert(editingContext != null, "editingContext should not be null"); Debug.Assert(!string.IsNullOrEmpty(originatingId), "originatingId should not be null or empty"); // show dialog appropriate to framework version var result = ShowNewFunctionImportDialog( functionImport.Function, functionImport.LocalName.Value, sModel, cModel, cContainer, DialogsResource.NewFunctionImportDialog_EditFunctionImportTitle, selectedObject); // if user selected OK on the dialog then create the FunctionImport if (DialogResult.OK == result.DialogResult) { var commands = new List <Command>(); var cp = new CommandProcessor(editingContext, originatingId, Resources.Tx_UpdateFunctionImport); CreateComplexTypeCommand createComplexTypeCommand = null; // Make the decision based on what is returned by the dialog. // If return type is a string and result schema is not null, that means the user would like to create a new complex type for the function import return. if (result.ReturnType is string && result.Schema != null) { createComplexTypeCommand = CreateMatchingFunctionImportCommand.AddCreateComplexTypeCommands( sModel, result.ReturnType as string, result.Schema.RawColumns, commands); } // If ReturnType is a complex type and result schema is not null, the complex type needs to be updated to be in sync with schema columns. else if (result.ReturnType is ComplexType && result.Schema != null) { var complexType = result.ReturnType as ComplexType; // Create Column properties dictionary. The keys will be either property's type-mapping column name if availabe or property's name. var propertiesDictionary = complexType.Properties().ToDictionary(p => EdmUtils.GetFunctionImportResultColumnName(functionImport, p)); CreateMatchingFunctionImportCommand.AddChangeComplexTypePropertiesCommands( complexType, propertiesDictionary, result.Schema.RawColumns, commands); } // construct Dictionary mapping property name to column name for FunctionImportMapping IDictionary <string, string> mapPropertyNameToColumnName = null; if (result.Schema != null) { mapPropertyNameToColumnName = ModelHelper.ConstructComplexTypePropertyNameToColumnNameMapping(result.Schema.Columns.Select(c => c.Name).ToList()); } // change the FunctionImport and FunctionImportMapping to match ChangeFunctionImportCommand cmdFuncImpSproc = null; // if result.IsComposable is true then set to True, but if false then use None if existing value is None, otherwise False var resultIsComposable = (result.IsComposable ? BoolOrNone.TrueValue : (BoolOrNone.NoneValue == functionImport.IsComposable.Value ? BoolOrNone.NoneValue : BoolOrNone.FalseValue)); if (createComplexTypeCommand == null) { cmdFuncImpSproc = new ChangeFunctionImportCommand( cContainer, functionImport, result.Function, result.FunctionName, resultIsComposable, true, result.ReturnType); // Create explicit function-import result type mapping if the return type is a complex type. if (result.ReturnType is ComplexType) { cmdFuncImpSproc.PostInvokeEvent += (o, eventArgs) => { if (functionImport != null && functionImport.FunctionImportMapping != null) { // CreateFunctionImportTypeMappingCommand will be no op function-import's return is unchanged. CommandProcessor.InvokeSingleCommand( cp.CommandProcessorContext , new CreateFunctionImportTypeMappingCommand( functionImport.FunctionImportMapping, result.ReturnType as ComplexType) { CreateDefaultScalarProperties = true, PropertyNameToColumnNameMap = mapPropertyNameToColumnName }); } }; } } else { // Pass in the pre-req command to create complex type to the command. cmdFuncImpSproc = new ChangeFunctionImportCommand( cContainer, functionImport, result.Function, result.FunctionName, resultIsComposable, createComplexTypeCommand); // Create explicit function-import result type mapping if the return type is a complex type. cmdFuncImpSproc.PostInvokeEvent += (o, eventArgs) => { if (functionImport != null && functionImport.FunctionImportMapping != null) { CommandProcessor.InvokeSingleCommand( cp.CommandProcessorContext, new CreateFunctionImportTypeMappingCommand( functionImport.FunctionImportMapping, createComplexTypeCommand) { CreateDefaultScalarProperties = true, PropertyNameToColumnNameMap = mapPropertyNameToColumnName }); } }; } commands.Add(cmdFuncImpSproc); commands.ForEach(x => cp.EnqueueCommand(x)); cp.Invoke(); } }
public ExplorerConceptualEntityContainer( EditingContext context, ConceptualEntityContainer entityContainer, ExplorerEFElement parent) : base(context, entityContainer, parent) { }