protected override void Context()
{
sut = new ObjectPathXmlAttributeMapper();
_container = A.Fake <IContainer>();
A.CallTo(() => _container.Resolve <IObjectPathFactory>()).Returns(new ObjectPathFactoryForSpecs());
_serializationContext = SerializationTransaction.Create(_container);
}
public void ReloadWithPKSimSettings()
{
var dataImporterSettings = new DataImporterSettings();
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET);
dataImporterSettings.AddNamingPatternMetaData(Constants.FILE, Constants.SHEET, "Species");
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _modelingXmlSerializerRepository.SerializerFor <ImporterConfiguration>();
var fileName = _dialogCreator.AskForFileToOpen("Save configuration", "xml files (*.xml)|*.xml|All files (*.*)|*.*",
Constants.DirectoryKey.PROJECT);
if (fileName.IsNullOrEmpty())
{
return;
}
var xel = XElement.Load(fileName); // We have to correctly handle the case of cancellation
var configuration = serializer.Deserialize <ImporterConfiguration>(xel, serializationContext);
dataImporterSettings.NameOfMetaDataHoldingMoleculeInformation = "Molecule";
dataImporterSettings.NameOfMetaDataHoldingMolecularWeightInformation = "Molecular Weight";
_dialogCreator.MessageBoxInfo(_dataImporter.ImportFromConfiguration
(
configuration,
_dataImporter.DefaultMetaDataCategoriesForObservedData(),
_dataImporter.ColumnInfosForObservedData(),
dataImporterSettings,
_dialogCreator.AskForFileToOpen(Captions.Importer.OpenFile, Captions.Importer.ImportFileFilter, Constants.DirectoryKey.OBSERVED_DATA)
)?.Count() + " data sets successfully imported");
}
}
public T Load <T>(string pkmlFileFullPath,
IDimensionFactory dimensionFactory = null,
IObjectBaseFactory objectBaseFactory = null,
IWithIdRepository withIdRepository = null,
ICloneManagerForModel cloneManagerForModel = null) where T : class
{
T loadedObject;
int version;
using (var serializationContext = SerializationTransaction.Create(
_container,
dimensionFactory ?? _dimensionFactory,
objectBaseFactory ?? _objectBaseFactory,
withIdRepository ?? new WithIdRepository(),
cloneManagerForModel ?? _cloneManagerForModel))
{
var element = XElement.Load(pkmlFileFullPath);
version = element.GetPKMLVersion();
convertXml(element, version);
var serializer = _serializerRepository.SerializerFor <T>();
if (!string.Equals(serializer.ElementName, element.Name.LocalName))
{
throw new OSPSuiteException(Error.CouldNotLoadObjectFromFile(pkmlFileFullPath, serializer.ElementName));
}
loadedObject = serializer.Deserialize <T>(element, serializationContext);
}
resolveReferenceIfRequired(loadedObject);
convert(loadedObject, version, x => x.Convert);
return(loadedObject);
}
private void loadDimensionsFromFile()
{
var serializer = _unitSystemXmlSerializerRepository.SerializerFor(_dimensionFactory);
var xel = XElement.Load(_pkSimConfiguration.DimensionFilePath);
serializer.Deserialize(_dimensionFactory, xel, SerializationTransaction.Create(_container));
}
public virtual string ToString <T>(T obj)
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
return(Serialize(obj, serializationContext).ToString());
}
}
public void Convert(XElement element)
{
foreach (var parameterCacheElement in element.Descendants("ParameterValuesCache").ToList())
{
var parameterValuesCache = new ParameterValuesCache();
foreach (var dataColumnNode in parameterCacheElement.Descendants(ConverterConstants.Serialization.DATA_TABLE_COLUMN))
{
var parameterValues = new ParameterValues(dataColumnNode.GetAttribute(CoreConstants.Serialization.Attribute.Name));
parameterValuesCache.Add(parameterValues);
}
var documentElement = parameterCacheElement.Descendants("DocumentElement").First();
foreach (var parameterValuesElement in documentElement.Descendants("ParameterValues"))
{
int index = 0;
foreach (var parameterValue in parameterValuesElement.Descendants())
{
var parameterValues = parameterValuesCache.ParameterValuesAt(index);
parameterValues.Add(parameterValue.Value.ConvertedTo <double>());
index++;
}
}
var writer = _container.Resolve <IXmlWriter <ParameterValuesCache> >();
var newElement = writer.WriteFor(parameterValuesCache, SerializationTransaction.Create());
var parent = parameterCacheElement.Parent;
parameterCacheElement.Remove();
parent.Add(newElement);
}
}
public override void GlobalContext()
{
base.GlobalContext();
_unitSystemXmlRepository = new UnitSystemXmlSerializerRepository();
_unitSystemXmlRepository.PerformMapping();
_serializationContext = SerializationTransaction.Create();
}
public SerializationContext Create(IEnumerable <DataRepository> dataRepositories = null, IEnumerable <IWithId> externalReferences = null)
{
var projectRetriever = _container.Resolve <IPKSimProjectRetriever>();
var project = projectRetriever.Current;
//do not use the pksim repository since we need to register the deserialized object afterwards
//this repository is only used to resolve the references
var withIdRepository = new WithIdRepository();
externalReferences?.Each(withIdRepository.Register);
var allRepositories = new List <DataRepository>();
if (project != null)
{
allRepositories.AddRange(project.All <IndividualSimulation>()
.Where(s => s.HasResults)
.Select(s => s.DataRepository)
.Union(project.AllObservedData));
}
if (dataRepositories != null)
{
allRepositories.AddRange(dataRepositories);
}
allRepositories.Each(withIdRepository.Register);
return(SerializationTransaction.Create(_dimensionFactory, _objectBaseFactory, withIdRepository, _cloneManagerForModel, allRepositories));
}
protected SerializationContext NewDeserializationContext()
{
var objectBaseFactory = IoC.Resolve <IObjectBaseFactory>();
var dimensionFactory = IoC.Resolve <IDimensionFactory>();
return(SerializationTransaction.Create(dimensionFactory, objectBaseFactory, new WithIdRepository(), new CloneManagerForModel(objectBaseFactory, new DataRepositoryTask(), new ModelFinalizer(new ObjectPathFactory(new AliasCreator()), new ReferencesResolver())), new List <DataRepository>()));
}
private void convertProject(IProject project)
{
if (!_projectObservedDataElementCache.Any())
{
return;
}
var serializerRepository = _container.Resolve <IPKSimXmlSerializerRepository>();
var serializer = serializerRepository.SerializerFor <DataRepository>();
using (var serializationContext = SerializationTransaction.Create(dimensionFactory: _dimensionFactory, withIdRepository: new WithIdRepository()))
{
var context = serializationContext;
_projectObservedDataElementCache.Each(e =>
{
_observedDataConvertor.ConvertDimensionIn(e);
project.AddObservedData(serializer.Deserialize <DataRepository>(e, context));
});
}
_projectObservedDataElementCache.Clear();
project.AllObservedData.Each(x => _observedDataConvertor.Convert(project, x, _originalVersion));
_converted = true;
}
private void convertIndividualSimulation(XElement individualSimulationElement)
{
//this value is not always available
var aucIV = individualSimulationElement.GetAttribute("aucIV");
if (string.IsNullOrEmpty(aucIV))
{
return;
}
var allCompoundPKElement = new XElement("AllCompoundPK");
individualSimulationElement.Add(allCompoundPKElement);
var aucIVValue = aucIV.ConvertedTo <double>();
//Add existing value to cache with a dummy compound name that will be replaced with the real compound name once the object
//are loaded
var compoundPK = new CompoundPK {
CompoundName = DUMMY_COMPOUND_NAME, AucIV = aucIVValue
};
var compoundPKSerializer = _serializerRepository.SerializerFor(compoundPK);
var compoundPKElement = compoundPKSerializer.Serialize(compoundPK, SerializationTransaction.Create());
allCompoundPKElement.Add(compoundPKElement);
}
public virtual void Save <T>(T obj, string fileName)
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
var xel = Serialize(obj, serializationContext);
xel.Save(fileName);
}
}
public virtual T Load <T>(string fileName, IDimensionFactory dimensionFactory = null, IEnumerable <DataRepository> dataRepositories = null)
{
using (var serializationContext = SerializationTransaction.Create(_container, dimensionFactory, dataRepositories: dataRepositories))
{
var xel = XElement.Load(fileName);
return(Deserialize <T>(xel, serializationContext));
}
}
public CurveChartTemplate Deserialize(XElement element)
{
using (var serializationContext = SerializationTransaction.Create(_dimensionFactory, _objectBaseFactory, _withIdRepository))
{
var chartTemplateSerializer = _modellingXmlSerializerRepository.SerializerFor(element);
return(chartTemplateSerializer.Deserialize <CurveChartTemplate>(element, serializationContext));
}
}
public XElement Serialize(CurveChartTemplate chartTemplate)
{
using (var serializationContext = SerializationTransaction.Create())
{
var chartSerializer = _modellingXmlSerializerRepository.SerializerFor(chartTemplate);
return(chartSerializer.Serialize(chartTemplate, serializationContext));
}
}
public virtual void Save(T objectToSerialize, string fileName)
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _serializerRepository.SerializerFor(objectToSerialize);
var xel = serializer.Serialize(objectToSerialize, serializationContext);
xel.Save(fileName);
}
}
public override void Load(DataRepository dataRepository, string fileName)
{
using (var context = SerializationTransaction.Create(_dimensionFactory, withIdRepository: new WithIdRepository()))
{
var xmlSerializer = _serializerRepository.SerializerFor(dataRepository);
var outputToDeserialize = XElement.Load(fileName);
xmlSerializer.Deserialize(dataRepository, outputToDeserialize, context);
}
}
public void Load(IPKParameterRepository pkParameterMetaDataRepository, string fileName)
{
using (var serializationContext = SerializationTransaction.Create(_dimensionFactory))
{
var serializer = _modellingXmlSerializerRepository.SerializerFor(pkParameterMetaDataRepository);
var xel = XElement.Load(fileName);
serializer.Deserialize(pkParameterMetaDataRepository, xel, serializationContext);
}
}
public virtual void Load(T objectToLoad, string fileName)
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _serializerRepository.SerializerFor(objectToLoad);
var element = XElement.Load(fileName);
serializer.Deserialize(objectToLoad, element, serializationContext);
}
}
public void Save(SimulationTransfer simulationTransfer, string fileName)
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _xmlSerializerRepository.SerializerFor(simulationTransfer);
var element = serializer.Serialize(simulationTransfer, serializationContext);
element.Save(fileName);
}
}
public void SaveToPKML <T>(T entityToSerialize, string fileName)
{
using (var serializationContext = SerializationTransaction.Create())
{
var xElement = serializeModelPart(entityToSerialize, serializationContext);
xElement.AddAttribute(Constants.Serialization.Attribute.VERSION, Constants.PKML_VERSION.ToString());
xElement.Save(fileName);
}
}
protected override void Context()
{
base.Context();
_element = new XElement("TOTO");
_entityToSerialize = A.Fake <IEntity>();
_entitySerializer = A.Fake <IXmlSerializer <SerializationContext> >();
A.CallTo(() => _entitySerializer.ObjectType).Returns(typeof(IEntity));
_serializationContext = SerializationTransaction.Create();
A.CallTo(() => _entitySerializer.Serialize(_entityToSerialize, _serializationContext)).Returns(_element);
A.CallTo(() => _serializerRepository.SerializerFor(_entityToSerialize)).Returns(_entitySerializer);
}
protected override void Context()
{
base.Context();
_entitySerializer = A.Fake <IXmlSerializer <SerializationContext> >();
_serializationContext = SerializationTransaction.Create(_container);
_deserializedObject = A.Fake <IEntity>();
_element = new XElement("TUTU");
A.CallTo(() => _entitySerializer.Deserialize <IEntity>(_element, _serializationContext)).Returns(_deserializedObject);
A.CallTo(() => _serializerRepository.SerializerFor(_element)).Returns(_entitySerializer);
}
public byte[] Serialize <TObject>(TObject objectToSerialize)
{
if (typeof(TObject) != typeof(IDiagramModel))
{
return(new byte[0]);
}
var serializer = _modelingXmlSerializerRepository.SerializerFor <IDiagramModel>();
using (var serializationContext = SerializationTransaction.Create())
return(_compress.Compress(XmlHelper.XmlContentToByte(serializer.Serialize(objectToSerialize, serializationContext))));
}
public virtual T FromString <T>(string serializationString)
{
if (string.IsNullOrEmpty(serializationString))
{
return(default(T));
}
using (var serializationContext = SerializationTransaction.Create(_container))
{
var xDoc = XDocument.Load(new StringReader(serializationString));
return(Deserialize <T>(xDoc.Root, serializationContext));
}
}
protected override void Context()
{
base.Context();
_entitySerializer = A.Fake <IXmlSerializer <SerializationContext> >();
_serializationContext = SerializationTransaction.Create(_container);
_deserializedObject = A.Fake <IEntity>();
A.CallTo(() => _entitySerializer.ObjectType).Returns(typeof(IEntity));
_element = new XElement("TUTU");
A.CallTo(() => _entitySerializer.Deserialize <IEntity>(_element, _serializationContext)).Returns(_deserializedObject);
//serializers only defined for type but not for element
A.CallTo(() => _serializerRepository.SerializerFor(typeof(IEntity))).Returns(_entitySerializer);
A.CallTo(() => _serializerRepository.SerializerFor(_element)).Throws(new SerializerNotFoundException("toto"));
}
public TObject Deserialize <TObject>(byte[] serializationByte)
{
if (typeof(TObject) != typeof(IDiagramModel))
{
return(default(TObject));
}
var serializer = _modelingXmlSerializerRepository.SerializerFor <IDiagramModel>();
using (var serializationContext = SerializationTransaction.Create())
{
var outputToDeserialize = XmlHelper.ElementFromBytes(_compress.Decompress(serializationByte));
return((TObject)serializer.Deserialize(outputToDeserialize, serializationContext));
}
}
protected override void DoStart()
{
var serializer = _unitSystemXmlSerializerRepository.SerializerFor(_dimensionFactory);
var xel = XElement.Load(_pkSimConfiguration.DimensionFilePath);
serializer.Deserialize(_dimensionFactory, xel, SerializationTransaction.Create());
//add pksim specific dimension
var inputDose = _dimensionFactory.AddDimension(new BaseDimensionRepresentation(), CoreConstants.Dimension.InputDose, "kg/kg");
inputDose.AddUnit("mg", 1e-6, 0);
inputDose.DefaultUnit = inputDose.AddUnit("mg/kg", 1e-6, 0);
inputDose.BaseUnit.Visible = false;
_dimensionNames = _dimensionFactory.GetDimensionNames().ToList();
_dimensionFactory.AddDimension(Constants.Dimension.NO_DIMENSION);
}
public override void Load(IGroupRepository groupRepository, string fileName)
{
groupRepository.Clear();
using (var serializationContext = SerializationTransaction.Create(_container, withIdRepository: new WithIdRepository()))
{
var serializer = _serializerRepository.SerializerFor(groupRepository);
var element = XElement.Load(fileName);
serializer.Deserialize(groupRepository, element, serializationContext);
}
//last step. groups only have reference to parents. We need to add them as child
foreach (var group in groupRepository.All().Where(x => x.Parent != null))
{
group.Parent.AddChild(group);
}
}
public ImporterConfiguration OpenXmlConfiguration()
{
using (var serializationContext = SerializationTransaction.Create(_container))
{
var serializer = _modelingXmlSerializerRepository.SerializerFor <ImporterConfiguration>();
var fileName = _dialogCreator.AskForFileToOpen("Open configuration", "xml files (*.xml)|*.xml|All files (*.*)|*.*", //move to constants and use filter
Constants.DirectoryKey.PROJECT);
if (fileName.IsNullOrEmpty())
{
return(null);
}
var xel = XElement.Load(fileName); // We have to correctly handle the case of cancellation
return(serializer.Deserialize <ImporterConfiguration>(xel, serializationContext));
}
}
