/// <summary>
/// Creates the version manager and delcares the existing content as the virst version of the project.
/// </summary>
public void StartVersioning(int firstVersionNumber = 1, string firstVersionLabel = "v1")
{
VersionManager = new VersionManager(this);
Version firstVersion = new Version(this)
{
Label = firstVersionLabel, Number = firstVersionNumber
};
VersionManager.Versions.Add(firstVersion);
ProjectVersion firstProjectVersion = this.SingleVersion;
firstProjectVersion.Version = firstVersion;
this.SingleVersion = null;
/* direct property base assignment is used to prevent
* methods reacting to the change of "UsesVersioning"
* property during an incoherent state */
usesVersioning = true;
ProjectVersions.Add(firstProjectVersion);
foreach (IVersionedItem versionedItem in ModelIterator.GetAllModelItems(firstProjectVersion).OfType <IVersionedItem>())
{
firstVersion.Items.Add(versionedItem);
VersionManager.AddVersionedItem(versionedItem);
}
/* Now listeners to the change of "UsesVersioning" can be notified */
UsesVersioning = true;
}
private static ProjectVersions GetProjectVersions(XmlElement xmlProject)
{
var projectVersions = new ProjectVersions();
foreach (XmlElement propertyGroup in xmlProject.Elements("PropertyGroup"))
{
var version = propertyGroup.Element("Version");
if (version != null)
{
projectVersions.Version = Version.Parse(version.InnerText);
}
var fileVersion = propertyGroup.Element("FileVersion");
if (fileVersion != null)
{
projectVersions.FileVersion = Version.Parse(fileVersion.InnerText);
}
var assemblyVersion = propertyGroup.Element("AssemblyVersion");
if (assemblyVersion != null)
{
projectVersions.AssemblyVersion = Version.Parse(assemblyVersion.InnerText);
}
}
return(projectVersions);
}
private XElement getConvertedElementFrom(byte[] serializationBytes, out int version)
{
var element = ElementFrom(serializationBytes);
version = versionFrom(element);
if (!ProjectVersions.CanLoadVersion(version))
{
throw new InvalidProjectVersionException(version);
}
convertXml(element, version);
return(element);
}
private (XElement element, int originalVersion, bool conversionHappened) getConvertedElementFrom(byte[] serializationBytes)
{
var element = ElementFrom(serializationBytes);
var originalVersion = versionFrom(element);
if (!ProjectVersions.CanLoadVersion(originalVersion))
{
throw new InvalidProjectVersionException(originalVersion);
}
var conversionHappened = convertXml(element, originalVersion);
return(element, originalVersion, conversionHappened);
}
public IPKSimProject Load(ISession session)
{
var projectFromDb = projectFromDatabase(session);
if (projectFromDb == null)
{
throw new InvalidProjectFileException();
}
if (ProjectVersions.CanLoadVersion(projectFromDb.Version))
{
return(projectFrom(projectFromDb));
}
//Project was created with a newer version of the software
throw new InvalidProjectVersionException(projectFromDb.Version);
}
//-------------------------------------------
private static void CreateSLN(ProjectVersions version)
{
//-----------------------------------
string slnFile = "ProjectFiles/ProjectBuilder" + version + ".sln";
StreamReader _reader = null;
string lineOfText;
StringBuilder sb = new StringBuilder();
if (false == System.IO.File.Exists(slnFile))
{
throw new Exception("File " + slnFile + " does not exists");
}
using (Stream stream = System.IO.File.OpenRead(slnFile))
{
_reader = new StreamReader(stream);
while (true)
{
lineOfText = _reader.ReadLine();
if (lineOfText == null)
{
string _class = sb.ToString();
_class = _class.Replace("{0}", ProjectPort);
_class = _class.Replace("{1}", PhysicalPath);
// _class=_class.Replace("{1}",Guid.NewGuid().ToString());
// _class=_class.Replace("{2}",Guid.NewGuid().ToString());
//-----------------------------------
string path = Globals.BaseDirectory + ProjectName + version + ".sln";
// Create a file to write to.
using (StreamWriter sw = File.CreateText(path))
{
sw.WriteLine(_class);
}
return;
//-----------------------------------
}
else
{
sb.Append(lineOfText + Environment.NewLine);
}
}
}
//-----------------------------------
}
public override async Task <ModelProject> MapToModel(SnapshotProject snapshot, ProjectContext projectContext)
{
_logger.AddDebug($"Loading project '{snapshot.Name}' from snapshot...", snapshot.Name);
var project = new ModelProject
{
Name = snapshot.Name,
Description = snapshot.Description,
Creation = _creationMetaDataFactory.Create()
};
//The entry point of our context structure.
var snapshotContext = new SnapshotContext(project, snapshot.Version);
project.Creation.InternalVersion = snapshot.Version;
project.Creation.Version = ProjectVersions.FindBy(snapshot.Version)?.VersionDisplay;
await allBuildingBlocksFrom(snapshot, snapshotContext);
var observedData = await observedDataFrom(snapshot.ObservedData, snapshotContext);
observedData?.Each(repository => addObservedDataToProject(project, repository));
var allSimulations = await allSimulationsFrom(project, projectContext, snapshot.Simulations, snapshotContext);
allSimulations?.Each(simulation => addSimulationToProject(project, simulation));
var allSimulationComparisons = await allSimulationComparisonsFrom(snapshot.SimulationComparisons, snapshotContext);
allSimulationComparisons?.Each(comparison => addComparisonToProject(project, comparison));
var allParameterIdentifications = await allParameterIdentificationsFrom(snapshot.ParameterIdentifications, snapshotContext);
allParameterIdentifications?.Each(parameterIdentification => addParameterIdentificationToProject(project, parameterIdentification));
var allQualificationPlans = await allQualificationPlansFrom(snapshot.QualificationPlans, snapshotContext);
allQualificationPlans?.Each(qualificationPlan => addQualificationPlanToProject(project, qualificationPlan));
//Map all classifications once project is loaded
await updateProjectClassifications(snapshot, snapshotContext);
return(project);
}
public override async Task <ModelProject> MapToModel(SnapshotProject snapshot)
{
var project = new ModelProject
{
Description = snapshot.Description,
Creation = _creationMetaDataFactory.Create()
};
project.Creation.InternalVersion = snapshot.Version;
project.Creation.Version = ProjectVersions.FindBy(snapshot.Version)?.VersionDisplay;
var buildingBlocks = await allBuidingBlocksFrom(snapshot);
buildingBlocks?.Each(project.AddBuildingBlock);
var observedData = await observedDataFrom(snapshot.ObservedData);
observedData?.Each(repository => addObservedDataToProject(project, repository));
var allSimulations = await allSmulationsFrom(snapshot.Simulations, project);
allSimulations?.Each(simulation => addSimulationToProject(project, simulation));
var allSimulationComparisons = await allSimulationComparisonsFrom(snapshot.SimulationComparisons, project);
allSimulationComparisons?.Each(comparison => addComparisonToProject(project, comparison));
var allParameterIdentifications = await allParameterIdentificationsFrom(snapshot.ParameterIdentifications, project);
allParameterIdentifications?.Each(parameterIdentification => addParameterIdentificationToProject(project, parameterIdentification));
var allQualificationPlans = await allQualificationPlansFrom(snapshot.QualificationPlans, project);
allQualificationPlans?.Each(qualificationPlan => addQualificationPlanToProject(project, qualificationPlan));
//Map all classifications once project is loaded
await updateProjectClassifications(snapshot, project);
return(project);
}
public IMoBiProject Load(IMoBiContext context)
{
var projectFromDb = projectFromDatabase();
if (projectFromDb == null)
{
return(null);
}
if (!ProjectVersions.CanLoadVersion(projectFromDb.Version))
{
throw new InvalidProjectFileException(projectFromDb.Version);
}
var project = projectFrom(projectFromDb);
_postSerializationStepsMaker.PerformPostDeserializationFor(project, projectFromDb.Version);
context.LoadFrom(project);
return(project);
}
private object deserialize(XElement element, IMoBiProject project, int version, Type type = null, SerializationContext parentSerializationContext = null)
{
object deserializedObject;
bool conversionHappened = false;
using (var serializationContext = _serializationContextFactory.Create(parentSerializationContext))
{
conversionHappened = convertXml(element, version, project);
IXmlSerializer <SerializationContext> serializer;
Type deserializeType;
if (type == null)
{
serializer = _repository.SerializerFor(element);
deserializeType = serializer.ObjectType;
}
else
{
serializer = serializeFor(type);
deserializeType = type;
}
var formulaCacheElement = getFormulaCacheElementFor(element, deserializeType);
conversionHappened = convertXml(formulaCacheElement, version, project) || conversionHappened;
deserializeFormula(formulaCacheElement, version, project, serializationContext);
deserializedObject = serializer.Deserialize(element, serializationContext);
}
//Performs the conversion to the latest project version
conversionHappened = convert(deserializedObject, version, project) || conversionHappened;
//Once the project was converted, update all formula references
_deserializedReferenceResolver.ResolveFormulaAndTemplateReferences(deserializedObject, project);
if (conversionHappened)
{
_eventPublisher.PublishEvent(new ObjectConvertedEvent(deserializedObject, ProjectVersions.FindBy(version)));
}
return(deserializedObject);
}
public InvalidProjectFileException(int projectVersion)
: base(AppConstants.ProjectVersionCannotBeLoaded(projectVersion, ProjectVersions.Current, ProjectVersions.ProjectIsTooOld(projectVersion), AppConstants.ProductSiteDownload))
{
}
public InvalidProjectVersionException(int projectVersion) :
base(PKSimConstants.Error.ProjectVersionCannotBeLoaded(projectVersion, ProjectVersions.Current,
ProjectVersions.ProjectIsTooOld(projectVersion), Constants.PRODUCT_SITE_DOWNLOAD))
{
}
private void updatePropertiesFor <TObject>(TObject deserializedObject, int version)
{
//convert object if required
var conversionHappened = convert(deserializedObject, version);
var simulation = deserializedObject as Simulation;
if (simulation != null)
{
_simulationUpdater.UpdateSimulation(simulation);
}
var individual = deserializedObject as Individual;
if (individual != null)
{
_referenceResolver.ResolveReferencesIn(individual);
}
var population = deserializedObject as Population;
if (population != null)
{
_referenceResolver.ResolveReferencesIn(population.FirstIndividual);
}
var lazyLoadable = deserializedObject as ILazyLoadable;
if (lazyLoadable != null)
{
lazyLoadable.IsLoaded = true;
}
if (conversionHappened && deserializedObject.IsAnImplementationOf <IObjectBase>())
{
_eventPublisher.PublishEvent(new ObjectBaseConvertedEvent(deserializedObject.DowncastTo <IObjectBase>(), ProjectVersions.FindBy(version)));
}
}