internal PatternModelSchema LoadModelAndDiagrams(
DslModeling.SerializationResult serializationResult,
DslModeling.Partition modelPartition,
string modelFileName,
DslModeling.Partition diagramPartition,
IEnumerable <string> diagramFileNames,
DslModeling.ISchemaResolver schemaResolver,
ValidationController validationController,
DslModeling.ISerializerLocator serializerLocator)
{
Guard.NotNull(() => serializationResult, serializationResult);
Guard.NotNull(() => modelPartition, modelPartition);
Guard.NotNullOrEmpty(() => modelFileName, modelFileName);
Guard.NotNull(() => diagramPartition, diagramPartition);
Guard.NotNull(() => diagramFileNames, diagramFileNames);
Guard.NotNull(() => schemaResolver, schemaResolver);
Guard.NotNull(() => serializerLocator, serializerLocator);
PatternModelSchema modelRoot;
if (!diagramPartition.Store.TransactionActive)
{
throw new InvalidOperationException(PatternModelDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
modelRoot = this.LoadModel(serializationResult, modelPartition, modelFileName, schemaResolver, validationController, serializerLocator);
if (serializationResult.Failed)
{
// don't try to deserialize diagram data if model load failed.
return(modelRoot);
}
var directory = this.GetDirectory(diagramPartition.Store);
var diagramSerializer = directory.GetSerializer(PatternModelSchemaDiagram.DomainClassId);
var views = modelRoot.Store.ElementDirectory.AllElements.OfType <ViewSchema>().ToList();
foreach (var view in views)
{
var diagramFileName = diagramFileNames.FirstOrDefault(file => Path.GetFileNameWithoutExtension(file).Contains(view.DiagramId));
if (diagramFileName == null)
{
PatternModelSerializationHelper.CreatePatternModelSchemaDiagram(serializationResult, diagramPartition, modelRoot, view.DiagramId);
}
else
{
this.LoadDiagram(serializationResult, diagramPartition, modelRoot, directory, diagramSerializer, diagramFileName, schemaResolver, validationController);
}
}
// Set tracking properties
ResetTrackingProperties(modelPartition.Store);
return(modelRoot);
}
public PatternModelSchema LoadModel(DslModeling.Store store, Stream stream, DslModeling.ISchemaResolver schemaResolver, DslModeling.ISerializerLocator serializerLocator)
{
Guard.NotNull(() => store, store);
Guard.NotNull(() => stream, stream);
if (!store.DefaultPartition.Store.TransactionActive)
{
throw new InvalidOperationException(PatternModelDomainModel.SingletonResourceManager.GetString("MissingTransaction"));
}
var directory = this.GetDirectory(store.DefaultPartition.Store);
var modelRootSerializer = directory.GetSerializer(PatternModelSchema.DomainClassId);
var serializationResult = new DslModeling.SerializationResult();
Debug.Assert(modelRootSerializer != null, @"Cannot find serializer for PatternModel!");
if (modelRootSerializer != null)
{
PatternModelSchema modelRoot = null;
var serializationContext = new DslModeling.SerializationContext(directory, string.Empty, serializationResult);
this.InitializeSerializationContext(store.DefaultPartition, serializationContext, true);
var transactionContext = new DslModeling.TransactionContext();
transactionContext.Add(DslModeling.SerializationContext.TransactionContextKey, serializationContext);
using (var tx = store.DefaultPartition.Store.TransactionManager.BeginTransaction(Resources.PatternModelSerializationHelper_TransactionDescriptionLoadingModel, true, transactionContext))
{
try
{
var settings = PatternModelSerializationHelper.Instance.CreateXmlReaderSettings(serializationContext, false);
using (var reader = XmlReader.Create(stream, settings))
{
reader.Read();
Encoding encoding;
if (this.TryGetEncoding(reader, out encoding))
{
serializationResult.Encoding = encoding;
}
DslModeling.SerializationUtilities.ResolveDomainModels(reader, serializerLocator, store.DefaultPartition.Store);
reader.MoveToContent();
modelRoot = modelRootSerializer.TryCreateInstance(serializationContext, reader, store.DefaultPartition) as PatternModelSchema;
if (modelRoot != null && !serializationResult.Failed)
{
this.ReadRootElement(serializationContext, modelRoot, reader, schemaResolver);
}
}
}
catch (XmlException ex)
{
DslModeling.SerializationUtilities.AddMessage(serializationContext, DslModeling.SerializationMessageKind.Error, ex);
}
if (modelRoot == null && !serializationResult.Failed)
{
modelRoot = this.CreateModelHelper(store.DefaultPartition);
}
if (tx.IsActive)
{
tx.Commit();
}
}
// Set tracking properties
ResetTrackingProperties(store);
return(modelRoot);
}
return(null);
}
/// <summary>
/// Loads the model from a filename.
/// </summary>
/// <param name="serializationResult">The seriazation result.</param>
/// <param name="partition">The state partition.</param>
/// <param name="fileName">the filename of the model.</param>
/// <param name="schemaResolver">The schemaresolver.</param>
/// <param name="validationController">The validation controller.</param>
/// <param name="serializerLocator">The serialization locator.</param>
/// <remarks>This overload is called by teh T4Runner engine.</remarks>
public override PatternModelSchema LoadModel(DslModeling.SerializationResult serializationResult, DslModeling.Partition partition, string fileName, DslModeling.ISchemaResolver schemaResolver, ValidationController validationController, DslModeling.ISerializerLocator serializerLocator)
{
var productLine = base.LoadModel(serializationResult, partition, fileName, schemaResolver, validationController, serializerLocator);
// Set tracking properties
if (partition != null)
{
ResetTrackingProperties(partition.Store);
}
return(productLine);
}
