private ICollection <string> GenerateXmlInternal(string folderPath, ICollection <SlotModel> slots) { Debug.Assert(!String.IsNullOrEmpty(folderPath)); Debug.Assert(slots != null); var fileList = new List <string>(); DateTime updateDateTime = DateTime.Now; var slotSummary = CreateSlotSummary(slots, updateDateTime); var serializer = new XmlFileSerializer <SlotSummary>(); string filePath = Path.Combine(folderPath, "SlotSummary.xml"); fileList.Add(filePath); serializer.Serialize(filePath, slotSummary); var slotDetailSerializer = new XmlFileSerializer <SlotDetail>(); foreach (var slot in slots) { var slotDetail = CreateSlotDetail(slot, updateDateTime); filePath = Path.Combine(folderPath, String.Concat(slot.Name, ".xml")); fileList.Add(filePath); slotDetailSerializer.Serialize(filePath, slotDetail); } return(fileList.AsReadOnly()); }
public void CreateOrUpdateTemplate(TemplateInfo t) { var path = Path.Combine(Paths.TemplatesPath, Path.GetFileNameWithoutExtension(t.TemplateFilePath) + ".xml"); var templates = GetTemplates(true); if (string.IsNullOrEmpty(t.Id)) { if (File.Exists(path) || File.Exists(Path.Combine(Paths.TemplatesPath, Path.GetFileName(t.TemplateFilePath) ?? throw new InvalidOperationException()))) { throw new Exception("Szablon o takiej nazwie już istnieje"); } t.Id = Guid.NewGuid().ToString(); var fName = Path.GetFileName(t.TemplateFilePath); File.Copy(t.TemplateFilePath, Path.Combine(Paths.TemplatesPath, fName)); t.TemplateFilePath = fName; } else { var item = templates.SingleOrDefault(x => string.Equals(x.Id, t.Id)); if (item != null) { File.Delete(Path.Combine(Paths.TemplatesPath, item.Name + ".xml")); } } XmlFileSerializer.Serialize(TemplateMapper.ToTemplate(t), path); }
public void Deserialize_NonexistingPath_DefaultReturned() { // Arrange var fileName = $"{Path.GetRandomFileName()}.xml"; var path = Path.Combine(Path.GetTempPath(), Path.Combine(Path.GetRandomFileName(), Path.GetRandomFileName())); var filePath = Path.Combine(path, fileName); if (Directory.Exists(path)) { Directory.Delete(path, true); } if (File.Exists(filePath)) { File.Delete(filePath); } var data = new SerializableBoolDummy(); data.BoolDummyProperty = true; var xmlSerializer = new XmlFileSerializer(log); // Act var deserializedData = xmlSerializer.Deserialize <SerializableBoolDummy>(filePath); // Assert Assert.IsTrue(deserializedData == null); }
public SlotModel Read(string filePath, string name, ClientSettings settings) { var slots = new List <SlotData>(); var serializer = new XmlFileSerializer <SlotSummary>(); try { slots = serializer.Deserialize(filePath).Slots; } catch (Exception ex) { _logger.ErrorFormat(ex, "{0}", ex.Message); } var slotData = slots.FirstOrDefault(x => x.GridData.Name == name); if (slotData != null) { var slot = AutoMapper.Mapper.Map <SlotData, SlotModel>(slotData); Protein protein = _proteinDictionary.GetProteinOrDownload(slotData.UnitInfo.ProjectID); // build unit info logic var unitInfoLogic = ServiceLocator.Resolve <UnitInfoLogic>(); unitInfoLogic.CurrentProtein = protein; unitInfoLogic.UnitInfoData = slotData.UnitInfo; slot.Prefs = _prefs; slot.Settings = settings; slot.UnitInfoLogic = unitInfoLogic; return(slot); } return(new SlotModel { Prefs = _prefs, Settings = settings }); }
public void Deserialize_IncorrectDeserializationType_DefaultReturned() { // Arrange var fileName = $"{Path.GetRandomFileName()}.xml"; var path = Path.GetTempPath(); var filePath = Path.Combine(path, fileName); Directory.CreateDirectory(path); if (File.Exists(filePath)) { File.Delete(filePath); } var data = new SerializableBoolDummy(); data.BoolDummyProperty = true; var xmlSerializer = new XmlFileSerializer(log); // Act var serializationResult = xmlSerializer.Serialize(filePath, data); var deserializedData = xmlSerializer.Deserialize <SerializableIntDummy>(filePath); // Assert Assert.IsTrue(deserializedData == null); }
public void Serialize_ExistingPath_FileCreated() { // Arrange var fileName = $"{Path.GetRandomFileName()}.xml"; var path = Path.GetTempPath(); var filePath = Path.Combine(path, fileName); Directory.CreateDirectory(path); if (File.Exists(filePath)) { File.Delete(filePath); } var data = new SerializableBoolDummy(); var xmlSerializer = new XmlFileSerializer(log); // Act var serializationResult = xmlSerializer.Serialize(filePath, data); // Assert Assert.IsTrue(File.Exists(filePath)); Assert.IsTrue(serializationResult); }
public void SerializeDeserialize_ExistingPath_Deserialized() { // Arrange var fileName = $"{Path.GetRandomFileName()}.xml"; var path = Path.GetTempPath(); var filePath = Path.Combine(path, fileName); Directory.CreateDirectory(path); if (File.Exists(filePath)) { File.Delete(filePath); } var data = new SerializableBoolDummy(); data.BoolDummyProperty = true; var defaultData = default(SerializableBoolDummy); var xmlSerializer = new XmlFileSerializer(log); // Act var serializationResult = xmlSerializer.Serialize(filePath, data); var deserializedData = xmlSerializer.Deserialize <SerializableBoolDummy>(filePath); // Assert Assert.IsTrue(serializationResult); Assert.IsFalse(deserializedData.Equals(defaultData)); Assert.IsTrue(deserializedData.Equals(data)); }
public SlotModel Read(string filePath, string name, ClientSettings settings) { var slots = new List<SlotData>(); var serializer = new XmlFileSerializer<SlotSummary>(); try { slots = serializer.Deserialize(filePath).Slots; } catch (Exception ex) { _logger.ErrorFormat(ex, "{0}", ex.Message); } var slotData = slots.FirstOrDefault(x => x.GridData.Name == name); if (slotData != null) { var slot = AutoMapper.Mapper.Map<SlotData, SlotModel>(slotData); Protein protein = _proteinDictionary.GetProteinOrDownload(slotData.UnitInfo.ProjectID); // build unit info logic var unitInfoLogic = ServiceLocator.Resolve<UnitInfoLogic>(); unitInfoLogic.CurrentProtein = protein; unitInfoLogic.UnitInfoData = slotData.UnitInfo; slot.Prefs = _prefs; slot.Settings = settings; slot.UnitInfoLogic = unitInfoLogic; return slot; } return new SlotModel { Prefs = _prefs, Settings = settings }; }
public void Serialize_NonexistingPath_ExceptionThrown() { // Arrange var fileName = $"{Path.GetRandomFileName()}.xml"; var path = Path.Combine(Path.GetTempPath(), Path.Combine(Path.GetRandomFileName(), Path.GetRandomFileName())); var filePath = Path.Combine(path, fileName); if (Directory.Exists(path)) { Directory.Delete(path, true); } if (File.Exists(filePath)) { File.Delete(filePath); } var data = new SerializableBoolDummy(); var xmlSerializer = new XmlFileSerializer(log); // Act var serializationResult = xmlSerializer.Serialize(filePath, data); // Assert phase is empty: expecting exception, nothing to assert }
/// ------------------------------------------------------------------------------------ /// <summary> /// Use this for creating new or existing elements /// </summary> /// <param name="parentElementFolder">E.g. "c:/MyProject/Sessions"</param> /// <param name="id">e.g. "ETR007"</param> /// <param name="idChangedNotificationReceiver"></param> /// <param name="componentFileFactory"></param> /// <param name="xmlFileSerializer">used to load/save</param> /// <param name="fileType"></param> /// <param name="prjElementComponentFileFactory"></param> /// <param name="componentRoles"></param> /// ------------------------------------------------------------------------------------ protected ProjectElement(string parentElementFolder, string id, Action <ProjectElement, string, string> idChangedNotificationReceiver, FileType fileType, Func <ProjectElement, string, ComponentFile> componentFileFactory, XmlFileSerializer xmlFileSerializer, ProjectElementComponentFile.Factory prjElementComponentFileFactory, IEnumerable <ComponentRole> componentRoles) { _componentFileFactory = componentFileFactory; ComponentRoles = componentRoles; RequireThat.Directory(parentElementFolder).Exists(); StageCompletedControlValues = (ComponentRoles == null ? new Dictionary <string, StageCompleteType>() : ComponentRoles.ToDictionary(r => r.Id, r => StageCompleteType.Auto)); ParentFolderPath = parentElementFolder; _id = id ?? GetNewDefaultElementName(); IdChangedNotificationReceiver = idChangedNotificationReceiver; MetaDataFile = prjElementComponentFileFactory(this, fileType, xmlFileSerializer, RootElementName); if (File.Exists(SettingsFilePath)) { Load(); } else { Directory.CreateDirectory(FolderPath); Save(); } }
public bool SaveSettings() { if (!IsSettingModifed()) { return(true); } if (string.IsNullOrEmpty(FilePath)) { return(false); } try { var serializer = new XmlFileSerializer <ConfigManager>(FilePath); serializer.Save(this); foreach (var item in Items) { item.IsModified = false; } return(true); } catch (Exception ex) { Log.Error(ex.ToString()); return(false); } }
/// ------------------------------------------------------------------------------------ public Session(string parentElementFolder, string id, Action <ProjectElement, string, string> idChangedNotificationReceiver, SessionFileType sessionFileType, Func <ProjectElement, string, ComponentFile> componentFileFactory, XmlFileSerializer xmlFileSerializer, ProjectElementComponentFile.Factory prjElementComponentFileFactory, IEnumerable <ComponentRole> componentRoles, PersonInformant personInformant, Project project) : base(parentElementFolder, id, idChangedNotificationReceiver, sessionFileType, componentFileFactory, xmlFileSerializer, prjElementComponentFileFactory, componentRoles) { _personInformant = personInformant; // ReSharper disable DoNotCallOverridableMethodsInConstructor // Using a 1-minute fudge factor is a bit of a kludge, but when a session is created from an // existing media file, it already has an ID, and there's no other way to tell it's "new". if (project != null && (id == null || MetaDataFile.GetCreateDate().AddMinutes(1) > DateTime.Now) && MetaDataFile.GetStringValue(SessionFileType.kCountryFieldName, null) == null && MetaDataFile.GetStringValue(SessionFileType.kRegionFieldName, null) == null && MetaDataFile.GetStringValue(SessionFileType.kContinentFieldName, null) == null && MetaDataFile.GetStringValue(SessionFileType.kAddressFieldName, null) == null) { // SP-876: Project Data not displayed in new sessions until after a restart. Program.SaveProjectMetadata(); if (!string.IsNullOrEmpty(project.Country)) { MetaDataFile.TrySetStringValue(SessionFileType.kCountryFieldName, project.Country); } if (!string.IsNullOrEmpty(project.Region)) { MetaDataFile.TrySetStringValue(SessionFileType.kRegionFieldName, project.Region); } if (!string.IsNullOrEmpty(project.Continent)) { MetaDataFile.TrySetStringValue(SessionFileType.kContinentFieldName, project.Continent); } if (!string.IsNullOrEmpty(project.Location)) { MetaDataFile.TrySetStringValue(SessionFileType.kAddressFieldName, project.Location); } } if (string.IsNullOrEmpty(MetaDataFile.GetStringValue(SessionFileType.kGenreFieldName, null))) { if (MetaDataFile.TrySetStringValue(SessionFileType.kGenreFieldName, GenreDefinition.UnknownType.Name)) { MetaDataFile.Save(); } } // ReSharper restore DoNotCallOverridableMethodsInConstructor if (_personInformant != null) { _personInformant.PersonNameChanged += HandlePersonsNameChanged; _personInformant.PersonUiIdChanged += HandlePersonsUiIdChanged; } }
public void Read_WhenRead_ThenNotThrowException() { // Arrange var serializer = new XmlFileSerializer(); var collection = new List <int>(); // Act - Assert Assert.DoesNotThrow(() => serializer.Read <int>("file4")); }
public void Write_WhenWrite_ThenNotThrowException() { // Arrange var serializer = new XmlFileSerializer(); var collection = new List <int>(); // Act - Assert Assert.DoesNotThrow(() => serializer.Write(collection, "file4")); }
public void WriteAndReadXmlTest() { var data1 = CreateTestList(); var serializer = new XmlFileSerializer<List<ProteinBenchmark>>(); serializer.Serialize("TestProteinBenchmark.xml", data1); var data2 = serializer.Deserialize("TestProteinBenchmark.xml"); ValidateTestList(data2); }
public void WriteAndReadXmlTest() { var data1 = CreateTestList(); var serializer = new XmlFileSerializer<List<UnitInfo>>(); serializer.Serialize("TestUnitInfo.xml", data1); var data2 = serializer.Deserialize("TestUnitInfo.xml"); Assert.IsTrue(data1.SequenceEqual(data2)); }
/// ------------------------------------------------------------------------------------ public NewComponentFile(string pathToAnnotatedFile, IEnumerable <FileType> fileTypes, IEnumerable <ComponentRole> componentRoles, XmlFileSerializer xmlFileSerializer, IProvideAudioVideoFileStatistics statisticsProvider, PresetGatherer presetProvider, FieldUpdater fieldUpdater) : base(null, pathToAnnotatedFile, fileTypes, componentRoles, xmlFileSerializer, statisticsProvider, presetProvider, fieldUpdater) { _fileTypes = fileTypes; Selected = true; }
public void WriteAndReadXmlTest() { var data1 = CreateTestList(); var serializer = new XmlFileSerializer <List <ProteinBenchmark> >(); serializer.Serialize("TestProteinBenchmark.xml", data1); var data2 = serializer.Deserialize("TestProteinBenchmark.xml"); ValidateTestList(data2); }
/// ------------------------------------------------------------------------------------ public Person(string parentElementFolder, string id, Action <ProjectElement, string, string> idChangedNotificationReceiver, PersonFileType personFileType, Func <ProjectElement, string, ComponentFile> componentFileFactory, XmlFileSerializer xmlFileSerializer, ProjectElementComponentFile.Factory prjElementComponentFileFactory, IEnumerable <ComponentRole> componentRoles) : base(parentElementFolder, id, idChangedNotificationReceiver, personFileType, componentFileFactory, xmlFileSerializer, prjElementComponentFileFactory, componentRoles) { }
public Task <IEnumerable <RecordListInfo> > GetRecords() { return(Task <IEnumerable <RecordListInfo> > .Factory.StartNew(() => { if (!Directory.Exists(Paths.RecordsPath)) { return null; } var dirs = Directory.GetDirectories(Paths.RecordsPath); var records = new List <RecordListInfo>(); var availableTemplatesCount = _templatesManager.GetTemplates().Count(); foreach (var s in dirs) { var recordXmlPath = Path.Combine(s, "record.xml"); var recordInfo = new RecordListInfo(); var record = XmlFileSerializer.Deserialize <Record>(recordXmlPath); foreach (var recordEntry in record.Entries) { UpdateRecordFile(record.RecordDate, recordEntry.FilePath, Path.Combine(s, recordEntry.FilePath)); } record = XmlFileSerializer.Deserialize <Record>(recordXmlPath); var recordItems = record.Entries.Select(recordEntry => new RecordListItemInfo { DisplayName = recordEntry.DisplayName, FilePath = recordEntry.FilePath, TemplateId = recordEntry.TemplateId, IsFilledIn = recordEntry.IsFilledIn, RecordDate = record.RecordDate }) .ToList(); recordInfo.RecordDate = record.RecordDate; recordInfo.RecordsInfo = recordItems; recordInfo.CanAddEntries = recordItems.Count < availableTemplatesCount; recordInfo.RecordId = record.RecordId; records.Add(recordInfo); } return records; })); }
public void Setup() { _testFieldSerializer = new TestFieldSerializer(); _fileType = new Mock <FileType>("Mocked", null); _fileType.Setup(f => f.GetIsCustomFieldId(It.Is <string>(id => id != "a" && id != "dates" && id != "b"))).Returns(true); var fieldSerializers = new Dictionary <string, IXmlFieldSerializer>(); fieldSerializers[_testFieldSerializer.ElementName] = _testFieldSerializer; _serializer = new XmlFileSerializer(fieldSerializers); _parentFolder = new TemporaryFolder("fileTypeTest"); _fields = new List <FieldInstance>(); }
public static ConfigManager NewInstance(string filepath) { FilePath = filepath; ConfigManager mgr = null; try { var serializer = new XmlFileSerializer <ConfigManager>(filepath); mgr = serializer.Load(); } catch (Exception ex) { Log.Error(ex.ToString()); } return(mgr ?? (new ConfigManager())); }
private IEnumerable <ComponentFile> GetFiles() { var dir = Path.Combine(Program.CurrentProject.FolderPath, FolderName); if (!Directory.Exists(dir)) { yield break; } var unknownFileType = new FileType[] { new UnknownFileType(null, null), new AudioFileType(null, null, null), new VideoFileType(null, null, null), new ImageFileType(null, null) }; var blankRoles = new ComponentRole[] {}; var blankSerializer = new XmlFileSerializer(null); var files = Directory.GetFiles(dir); foreach (var file in files.Where(f => !f.EndsWith(Settings.Default.MetadataFileExtension))) { yield return(new ComponentFile(null, file, unknownFileType, blankRoles, blankSerializer, null, null, null)); } }
private static void UpdateRecordFile(DateTime recordDate, string fileName, string fullPath) { var hasBeenUpdated = false; var fInfo = new FileInfo(fullPath); using (var package = new ExcelPackage(fInfo)) { if (package.Workbook.Worksheets == null || package.Workbook.Worksheets.Count == 0) { throw new Exception("Plik '" + fileName + "' ma nieprawidłową strukturę. Nie odnaleziono żadnej zakładki"); } var sheet = package.Workbook.Worksheets[1]; if (sheet.Dimension.Rows > 1 && sheet.Cells[2, 1]?.Value != null) { hasBeenUpdated = true; } } var recordFile = Path.Combine(Paths.RecordsPath, recordDate.ToRecordDateString(), "record.xml"); var record = XmlFileSerializer.Deserialize <Record>(recordFile); if (record.Entries == null || record.Entries.Length <= 0) { return; } foreach (var t in record.Entries) { if (string.Equals(t.FilePath?.ToLower(), fileName.ToLower())) { t.IsFilledIn = hasBeenUpdated; } } XmlFileSerializer.Serialize(record, recordFile); }
public IEnumerable <TemplateInfo> GetTemplates(bool includeDisabled = false) { if (!Directory.Exists(Paths.TemplatesPath)) { return(null); } var files = Directory.GetFiles(Paths.TemplatesPath, "*.xml"); var templates = new List <TemplateInfo>(); foreach (var file in files) { var template = XmlFileSerializer.Deserialize <Template>(file); if (!includeDisabled && !template.IsEnabled) { continue; } templates.Add(TemplateMapper.ToTemplateInfo(template)); } return(templates); }
public IEnumerable<SlotData> Read(string filePath) { var serializer = new XmlFileSerializer<SlotSummary>(); return serializer.Deserialize(filePath).Slots; }
public IEnumerable <SlotData> Read(string filePath) { var serializer = new XmlFileSerializer <SlotSummary>(); return(serializer.Deserialize(filePath).Slots); }
public void CreateOrUpdateRecord(RecordInfo recordInfo) { if (recordInfo == null) { throw new Exception("Obiekt nowej inwentaryzacji nie został zdefiniowany"); } if (recordInfo.RecordsDate == null) { throw new Exception("Data inwentaryzacji nie może być pusta!"); } if (recordInfo.RecordTypes == null) { throw new Exception("Nie wskazano szablonów inwentaryzacji"); } var recordsPath = Path.Combine(Paths.RecordsPath, recordInfo.RecordsDate.ToRecordDateString()); var recordInfoFilePath = Path.Combine(recordsPath, "record.xml"); var templates = recordInfo.RecordTypes.Where(x => x.IsSelected).Select(x => x.TemplateInfo); try { if (string.IsNullOrEmpty(recordInfo.Id)) { if (Directory.Exists(recordsPath)) { throw new Exception("Inwentaryzacje na dzień " + recordInfo.RecordsDate.ToRecordDateString() + " już istnieją! Proszę wybrać inną datę lub zmodyfikować istniejące zestawienia"); } Directory.CreateDirectory(recordsPath); var record = new Record(); var entries = new List <RecordEntry>(); foreach (var templateInfo in templates) { var templateFullPath = Path.Combine(Paths.TemplatesPath, templateInfo.TemplateFilePath); File.Copy(templateFullPath, Path.Combine(recordsPath, templateInfo.TemplateFilePath)); entries.Add(new RecordEntry { DisplayName = templateInfo.Name, FilePath = templateInfo.TemplateFilePath, TemplateId = templateInfo.Id }); } record.Entries = entries.ToArray(); record.RecordId = Guid.NewGuid().ToString(); record.RecordDate = recordInfo.RecordsDate.Value; XmlFileSerializer.Serialize(record, recordInfoFilePath); } else { var record = XmlFileSerializer.Deserialize <Record>(recordInfoFilePath); var existingIds = record.Entries.Select(x => x.TemplateId).ToList(); var entriesToAdd = new List <RecordEntry>(); foreach (var templateInfo in templates) { if (!existingIds.Contains(templateInfo.Id)) { var templateFullPath = Path.Combine(Paths.TemplatesPath, templateInfo.TemplateFilePath); File.Copy(templateFullPath, Path.Combine(recordsPath, templateInfo.TemplateFilePath)); entriesToAdd.Add(new RecordEntry { DisplayName = templateInfo.Name, FilePath = templateInfo.TemplateFilePath, TemplateId = templateInfo.Id }); } } var entries = record.Entries.ToList(); entries.AddRange(entriesToAdd); record.Entries = entries.ToArray(); XmlFileSerializer.Serialize(record, recordInfoFilePath); } } catch { Directory.Delete(recordsPath, true); throw; } }
private IEnumerable<string> DoXmlGeneration(string folderPath, IEnumerable<SlotModel> slots) { Debug.Assert(!String.IsNullOrEmpty(folderPath)); Debug.Assert(slots != null); var fileList = new List<string>(); DateTime updateDateTime = DateTime.Now; var slotSummary = CreateSlotSummary(slots, updateDateTime); var serializer = new XmlFileSerializer<SlotSummary>(); string filePath = Path.Combine(Path.GetTempPath(), "SlotSummary.xml"); fileList.Add(filePath); serializer.Serialize(filePath, slotSummary); var slotDetailSerializer = new XmlFileSerializer<SlotDetail>(); foreach (var slot in slots) { var slotDetail = CreateSlotDetail(slot, updateDateTime); filePath = Path.Combine(Path.GetTempPath(), String.Concat(slot.Name, ".xml")); fileList.Add(filePath); slotDetailSerializer.Serialize(filePath, slotDetail); } return fileList.AsReadOnly(); }