internal override void DetermineIfArtifactIsDesignerSafe()
{
// XmlSchemaValidator by default does not report any errors or warning if the namespace of the validated document
// does not match the targetNamespace in the schema considering the schema not being applicable. With XmlReader
// it is possible to pass XmlSchemaValidationFlags.ReportValidationWarnings to be notified if this happens. However
// it is not possible to pass this flag when using XDocument.Validate. Therefore before trying to validate the Xml
// we just check that this is a known edmx namespace. If it is not we set the flag to false and skip validating.
if (IsDesignerSafe = SchemaManager.GetEDMXNamespaceNames().Contains(XDocument.Root.Name.NamespaceName))
{
XDocument.Validate(
EscherAttributeContentValidator.GetInstance(SchemaVersion).EdmxSchemaSet,
(sender, args) => IsDesignerSafe = false);
}
}
internal override bool IsXmlValid()
{
// If there is a VSXmlModelProvider, we should be able to find a docdata for it.
// In any other case, it doesn't matter whether there is document data or not.
var docData = VSHelpers.GetDocData(PackageManager.Package, Uri.LocalPath);
Debug.Assert(
!(XmlModelProvider is VSXmlModelProvider) || docData != null, "Using a VSXmlModelProvider but docData is null for Artifact!");
try
{
XmlDocument xmldoc;
if (docData != null)
{
var textLines = VSHelpers.GetVsTextLinesFromDocData(docData);
Debug.Assert(textLines != null, "Failed to get IVSTextLines from docdata");
xmldoc = EdmUtils.SafeLoadXmlFromString(VSHelpers.GetTextFromVsTextLines(textLines));
}
else
{
// If there is no docdata then attempt to create the XmlDocument from the internal
// XLinq tree in the artifact
xmldoc = new XmlDocument();
xmldoc.Load(XDocument.CreateReader());
}
// For the most part, the Edmx schema version of an artifact should be in sync with the schema version
// that is compatible with the project's target framework; except when the user adds an existing edmx to a project (the version could be different).
// For all cases, we always want to validate using the XSD's version that matches the artifact's version.
var documentSchemaVersion = base.SchemaVersion;
Debug.Assert(
EntityFrameworkVersion.IsValidVersion(documentSchemaVersion),
"The EF Schema Version is not valid. Value:"
+ (documentSchemaVersion != null ? documentSchemaVersion.ToString() : "null"));
// does the XML parse? If not, the load call below will throw
if (EntityFrameworkVersion.IsValidVersion(documentSchemaVersion))
{
var nsMgr = SchemaManager.GetEdmxNamespaceManager(xmldoc.NameTable, documentSchemaVersion);
// Do XSD validation on the document.
xmldoc.Schemas = EscherAttributeContentValidator.GetInstance(documentSchemaVersion).EdmxSchemaSet;
var svec = new SchemaValidationErrorCollector();
// remove runtime specific lines
// find the ConceptualModel Schema node
RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Configurations", nsMgr);
RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Runtime/edmx:ConceptualModels", nsMgr);
RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Runtime/edmx:StorageModels", nsMgr);
RemoveRunTimeNode(xmldoc, "/edmx:Edmx/edmx:Runtime/edmx:Mappings", nsMgr);
xmldoc.Validate(svec.ValidationCallBack);
return(svec.ErrorCount == 0);
}
}
catch
{
}
return(false);
}
internal override AttributeContentValidator GetAttributeContentValidator(EFArtifact artifact)
{
return(EscherAttributeContentValidator.GetInstance(artifact.SchemaVersion));
}
protected override void InvokeInternal(CommandProcessorContext cpc)
{
if (null == _conceptualEntityModel)
{
Debug.Fail("Null ConceptualEntityModel");
return;
}
var artifact = _conceptualEntityModel.Artifact;
if (null == artifact)
{
Debug.Fail("Null Artifact");
return;
}
var artifactSet = artifact.ArtifactSet;
if (null == artifactSet)
{
Debug.Fail("Null ArtifactSet");
return;
}
// make sure this name doesn't conflict with an EntityContainer name
foreach (var bec in _conceptualEntityModel.EntityContainers())
{
if (_newNamespace == bec.LocalName.Value)
{
var msg = string.Format(
CultureInfo.CurrentCulture, Resources.EntityContainerNameConflictsWithNamespaceName, _newNamespace);
throw new CommandValidationFailedException(msg);
}
}
// check to see if the new namespace is valid
if (EscherAttributeContentValidator.GetInstance(artifact.SchemaVersion)
.IsValidAttributeValue(_newNamespace, _conceptualEntityModel.Namespace))
{
var previousConceptualNamespace = _conceptualEntityModel.Namespace.Value;
if (string.IsNullOrEmpty(previousConceptualNamespace))
{
Debug.Fail("Null or empty conceptual namespace");
return;
}
// find all Symbols in the ArtifactSet which have first part
// equal to existing previousConceptualNamespace
var allElementsWithConceptualNamespaceSymbol =
artifactSet.GetElementsContainingFirstSymbolPart(previousConceptualNamespace);
// change all references which include the namespace to the new namespace
foreach (var element in allElementsWithConceptualNamespaceSymbol)
{
var itemBindings = element.GetDependentBindings();
foreach (var itemBinding in itemBindings)
{
itemBinding.UpdateRefNameNamespaces(
previousConceptualNamespace, _newNamespace);
}
}
// now update the namespace attribute itself
_conceptualEntityModel.Namespace.Value = _newNamespace;
// symbols need to be recalculated throughout the
// CSDL, MSL & DesignerInfo sections, and bindings need to be rebound ...
XmlModelHelper.NormalizeAndResolve(_conceptualEntityModel);
if (artifact.MappingModel() != null)
{
XmlModelHelper.NormalizeAndResolve(artifact.MappingModel());
}
if (artifact.DesignerInfo() != null)
{
XmlModelHelper.NormalizeAndResolve(artifact.DesignerInfo());
}
}
else
{
// if not a valid namespace, throw an error message
var msg = string.Format(CultureInfo.CurrentCulture, Resources.InvalidNamespaceName, _newNamespace);
throw new CommandValidationFailedException(msg);
}
}
