Ejemplo n.º 1
0
        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());
        }
Ejemplo n.º 2
0
        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);
        }
Ejemplo n.º 3
0
        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);
        }
Ejemplo n.º 4
0
        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
            });
        }
Ejemplo n.º 5
0
        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);
        }
Ejemplo n.º 6
0
        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);
        }
Ejemplo n.º 7
0
        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));
        }
Ejemplo n.º 8
0
      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 };
      }
Ejemplo n.º 9
0
        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
        }
Ejemplo n.º 10
0
        /// ------------------------------------------------------------------------------------
        /// <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();
            }
        }
Ejemplo n.º 11
0
        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);
            }
        }
Ejemplo n.º 12
0
        /// ------------------------------------------------------------------------------------
        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;
            }
        }
Ejemplo n.º 13
0
        public void Read_WhenRead_ThenNotThrowException()
        {
            // Arrange
            var serializer = new XmlFileSerializer();
            var collection = new List <int>();

            // Act - Assert
            Assert.DoesNotThrow(() => serializer.Read <int>("file4"));
        }
Ejemplo n.º 14
0
        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);
      }
Ejemplo n.º 16
0
        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));
        }
Ejemplo n.º 17
0
 /// ------------------------------------------------------------------------------------
 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;
 }
Ejemplo n.º 18
0
        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);
        }
Ejemplo n.º 19
0
 /// ------------------------------------------------------------------------------------
 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;
            }));
        }
Ejemplo n.º 21
0
        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>();
        }
Ejemplo n.º 22
0
        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()));
        }
Ejemplo n.º 23
0
        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);
        }
Ejemplo n.º 25
0
        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);
        }
Ejemplo n.º 26
0
 public IEnumerable<SlotData> Read(string filePath)
 {
    var serializer = new XmlFileSerializer<SlotSummary>();
    return serializer.Deserialize(filePath).Slots;
 }
Ejemplo n.º 27
0
        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;
            }
        }
Ejemplo n.º 29
0
        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();
        }