/// <summary>
        /// Create a zip file containing a dictionary configuration for the user to share, into destinationZipPath. LT-17397.
        /// </summary>
        internal static void ExportConfiguration(DictionaryConfigurationModel configurationToExport, string destinationZipPath, FdoCache cache)
        {
            if (configurationToExport == null)
            {
                throw new ArgumentNullException("configurationToExport");
            }
            if (destinationZipPath == null)
            {
                throw new ArgumentNullException("destinationZipPath");
            }
            if (cache == null)
            {
                throw new ArgumentNullException("cache");
            }
            if (destinationZipPath == string.Empty)
            {
                throw new ArgumentException("destinationDirectory");
            }

            using (var zip = new ZipFile())
            {
                zip.AddFile(configurationToExport.FilePath, "/");
                PrepareCustomFieldsExport(cache).ForEach(file => zip.AddFile(file, "/"));
                zip.AddFile(PrepareStylesheetExport(cache), "/");
                zip.Save(destinationZipPath);
            }
        }
示例#2
0
        public void PrepareImport_SuggestsUniqueLabelIfSameLabelAlreadyExists()
        {
            // More test setup

            var alreadyExistingModelWithSameLabel = new DictionaryConfigurationModel
            {
                Label        = configLabel,
                Publications = new List <string>(),
            };
            var anotherAlreadyExistingModel = new DictionaryConfigurationModel
            {
                Label        = "importexportConfiguration-Imported1",
                Publications = new List <string>(),
            };

            _controller._configurations.Add(alreadyExistingModelWithSameLabel);
            _controller._configurations.Add(anotherAlreadyExistingModel);

            // SUT
            _controller.PrepareImport(_zipFile);

            Assert.That(_controller._originalConfigLabel, Is.EqualTo(configLabel),
                        "This should have been the original label of the config to import.");
            Assert.That(_controller.NewConfigToImport.Label, Is.EqualTo("importexportConfiguration-Imported2"),
                        "This should be a new and different label since the original label is already taken.");
        }
        /// <summary>
        /// Helper.
        /// </summary>
        public UploadToWebonaryModel SetUpModel()
        {
            ConfiguredXHTMLGenerator.AssemblyFile = "xWorksTests";

            var testConfig = new Dictionary <string, DictionaryConfigurationModel>();

            testConfig["Test Config"] = new DictionaryConfigurationModel
            {
                Parts = new List <ConfigurableDictionaryNode> {
                    new ConfigurableDictionaryNode {
                        FieldDescription = "SIL.FieldWorks.XWorks.TestRootClass"
                    }
                }
            };

            return(new UploadToWebonaryModel(m_mediator)
            {
                SiteName = "site",
                UserName = "******",
                Password = "******",
                SelectedPublication = "Test publication",
                SelectedConfiguration = "Test Config",
                Configurations = testConfig
            });
        }
示例#4
0
        private string UserRequestsOverwrite_Helper()
        {
            // This model has the same label but a non-colliding filename. Proves overwrite the code will always overwrite.
            var alreadyExistingModelWithSameLabel = new DictionaryConfigurationModel
            {
                Label        = configLabel,
                Publications = new List <string> {
                    "Main Dictionary", "unknown pub 1", "unknown pub 2"
                },
                FilePath = Path.Combine(_projectConfigPath, "Different" + configFilename)
            };

            FileUtils.WriteStringtoFile(alreadyExistingModelWithSameLabel.FilePath, "arbitrary file content", Encoding.UTF8);
            var anotherAlreadyExistingModel = new DictionaryConfigurationModel
            {
                Label        = "importexportConfiguration-Imported1",
                Publications = new List <string> {
                    "Main Dictionary", "unknown pub 1", "unknown pub 2"
                },
                FilePath = Path.GetTempPath() + configFilename
            };

            DictionaryConfigurationManagerController.GenerateFilePath(_projectConfigPath, _controller._configurations,
                                                                      anotherAlreadyExistingModel);
            FileUtils.WriteStringtoFile(anotherAlreadyExistingModel.FilePath, "arbitrary file content", Encoding.UTF8);

            _controller._configurations.Add(alreadyExistingModelWithSameLabel);
            _controller._configurations.Add(anotherAlreadyExistingModel);

            _controller.PrepareImport(_zipFile);

            return(alreadyExistingModelWithSameLabel.FilePath);
        }
示例#5
0
 public HeadwordNumbersController(IHeadwordNumbersView view, DictionaryConfigurationModel model, LcmCache cache)
 {
     if (view == null || model == null || cache == null)
     {
         throw new ArgumentNullException();
     }
     _view             = view;
     _model            = model;
     _cache            = cache;
     _homographConfig  = GetHeadwordConfiguration();
     _view.Description = string.Format(xWorksStrings.ConfigureHomograph_ConfigDescription,
                                       model.IsReversal ? xWorksStrings.ReversalIndex : xWorksStrings.Dictionary,
                                       Environment.NewLine,
                                       model.Label);
     _view.SetWsFactoryForCustomDigits(cache.WritingSystemFactory);
     _view.AvailableWritingSystems = cache.LangProject.CurrentAnalysisWritingSystems.Union(cache.LangProject.CurrentVernacularWritingSystems);
     _view.CustomDigits            = _homographConfig.CustomHomographNumberList;
     if (_cache.LangProject.AllWritingSystems.Any(ws => ws.Id == _homographConfig.HomographWritingSystem))
     {
         _view.HomographWritingSystem = string.IsNullOrEmpty(_homographConfig.HomographWritingSystem)
                                 ? null
                                 : _cache.LangProject.AllWritingSystems.First(ws => ws.Id == _homographConfig.HomographWritingSystem).DisplayLabel;
     }
     else
     {
         _view.HomographWritingSystem = _cache.LangProject.AllWritingSystems.First().DisplayLabel;
     }
     _view.HomographBefore         = _homographConfig.HomographNumberBefore;
     _view.ShowHomograph           = _homographConfig.ShowHwNumber;
     _view.ShowHomographOnCrossRef = _model.IsReversal ? _homographConfig.ShowHwNumInReversalCrossRef : _homographConfig.ShowHwNumInCrossRef;
     _view.ShowSenseNumber         = _model.IsReversal ? _homographConfig.ShowSenseNumberReversal : _homographConfig.ShowSenseNumber;
     _view.OkButtonEnabled         = _homographConfig.CustomHomographNumberList == null ||
                                     !_homographConfig.CustomHomographNumberList.Any() || _homographConfig.CustomHomographNumberList.Count == 10;
     _view.CustomDigitsChanged += OnViewCustomDigitsChanged;
 }
示例#6
0
        /// <summary>
        /// This method will copy configuration node values from newDefaultModelPath over the matching nodes in oldDefaultModelPath.
        /// </summary>
        /// <remarks>Intended to be used only on defaults, not on data with user changes.</remarks>
        internal static DictionaryConfigurationModel LoadConfigWithCurrentDefaults(string oldDefaultModelPath, LcmCache cache, string newDefaultPath)
        {
            var oldDefaultConfigs = new DictionaryConfigurationModel(oldDefaultModelPath, cache);
            var newDefaultConfigs = new DictionaryConfigurationModel(newDefaultPath, cache);

            return(LoadConfigWithCurrentDefaults(oldDefaultConfigs, newDefaultConfigs));
        }
示例#7
0
        protected override void ShowRecord()
        {
            if (!m_fullyInitialized || IsDisposed || m_mainView.IsDisposed || !Visible)
            {
                return;
            }
            base.ShowRecord();
            var cmo = Clerk.CurrentObject;

            // Don't steal focus
            Enabled = false;
            m_mainView.DocumentCompleted += EnableRecordDocView;
            if (cmo != null && cmo.Hvo > 0)
            {
                var configurationFile = DictionaryConfigurationListener.GetCurrentConfiguration(m_propertyTable);
                if (String.IsNullOrEmpty(configurationFile))
                {
                    m_mainView.DocumentText = String.Format("<html><body><p>{0}</p></body></html>",
                                                            xWorksStrings.ksNoConfiguration);
                    return;
                }
                var configuration = new DictionaryConfigurationModel(configurationFile, Cache);
                var xhtmlPath     = ConfiguredXHTMLGenerator.SavePreviewHtmlWithStyles(new [] { cmo.Hvo }, null, configuration, m_propertyTable);
                m_mainView.Url = new Uri(xhtmlPath);
                m_mainView.Refresh(WebBrowserRefreshOption.Completely);
            }
            else
            {
                m_mainView.DocumentText = "<html><body></body></html>";
            }
        }
示例#8
0
        /// <summary>
        /// When a user selects a Reversal Index configuration in the Reversal Indexes area
        /// to describe how to arrange and show their
        /// reversal index entries, or in the
        /// Bulk Edit Reversal Entries area, we also need to set the Reversal Index Guid property to set which
        /// set of reversal index entries should be shown in the XhtmlDocView.
        /// Do that.
        /// </summary>
        public static void SetReversalIndexGuidBasedOnReversalIndexConfiguration(PropertyTable propertyTable, LcmCache cache)
        {
            var reversalIndexConfiguration = propertyTable.GetStringProperty("ReversalIndexPublicationLayout", string.Empty);

            if (string.IsNullOrEmpty(reversalIndexConfiguration))
            {
                return;
            }

            var model = new DictionaryConfigurationModel(reversalIndexConfiguration, cache);
            var reversalIndexConfigWritingSystemLanguage = model.WritingSystem;

            var currentAnalysisWsList = cache.LanguageProject.AnalysisWritingSystems;
            var wsObj = currentAnalysisWsList.FirstOrDefault(ws => ws.Id == reversalIndexConfigWritingSystemLanguage);

            if (wsObj == null || wsObj.DisplayLabel.ToLower().Contains("audio"))
            {
                return;
            }
            var riRepo     = cache.ServiceLocator.GetInstance <IReversalIndexRepository>();
            var mHvoRevIdx = riRepo.FindOrCreateIndexForWs(wsObj.Handle).Hvo;
            var revGuid    = cache.ServiceLocator.GetInstance <ICmObjectRepository>().GetObject(mHvoRevIdx).Guid;

            propertyTable.SetProperty("ReversalIndexGuid", revGuid.ToString(), true);
            propertyTable.SetPropertyPersistence("ReversalIndexGuid", true);
        }
示例#9
0
        internal static void SetWritingSystemForReversalModel(DictionaryConfigurationModel convertedModel, LcmCache cache)
        {
            if (!convertedModel.IsReversal || !string.IsNullOrEmpty(convertedModel.WritingSystem))             // don't change existing WS's
            {
                return;
            }
            var writingSystem = cache.ServiceLocator.WritingSystems.AnalysisWritingSystems
                                .Where(x => x.DisplayLabel == convertedModel.Label).Select(x => x.IcuLocale).FirstOrDefault();

            // If the label didn't get us a writing system then we need to attempt to extract the writing system from the filename
            if (writingSystem == null)
            {
                // old copies looked like this 'my name-French-#frenc343.extension'
                var fileParts = convertedModel.FilePath.Split('-');
                if (fileParts.Length == 3)
                {
                    writingSystem = cache.ServiceLocator.WritingSystems.AnalysisWritingSystems
                                    .Where(x => x.DisplayLabel == fileParts[1]).Select(x => x.IcuLocale).FirstOrDefault();
                }
                else
                {
                    writingSystem = "";
                }
            }
            convertedModel.WritingSystem = writingSystem;
        }
示例#10
0
        public void Save_SetsModelContents()
        {
            var testConfig = new DictionaryHomographConfiguration
            {
                HomographNumberBefore = true,
                ShowHwNumInCrossRef   = false,
                ShowSenseNumber       = false,
            };
            var view = new TestHeadwordNumbersView {
                HomographBefore = false, ShowHomograph = true, ShowSenseNumber = true
            };
            var model = new DictionaryConfigurationModel {
                HomographConfiguration = testConfig
            };
            // ReSharper disable once UnusedVariable
            var testController = new HeadwordNumbersController(view, model, Cache);

            view.Show();
            view.HomographBefore         = false;
            view.ShowHomographOnCrossRef = true;
            view.ShowSenseNumber         = true;
            // SUT
            testController.Save();
            // Verify save in Dictionary Config
            Assert.IsFalse(model.HomographConfiguration.HomographNumberBefore);
            Assert.IsTrue(model.HomographConfiguration.ShowHwNumInCrossRef);
            Assert.IsTrue(model.HomographConfiguration.ShowSenseNumber);
        }
        /// <summary>Returns a deep clone of this DCM. Caller is responsible to choose a unique FilePath</summary>
        public DictionaryConfigurationModel DeepClone()
        {
            var clone = new DictionaryConfigurationModel();

            // Copy everything over at first, importantly handling strings and primitives.
            var properties = typeof(DictionaryConfigurationModel).GetProperties();

            foreach (var property in properties.Where(prop => prop.CanWrite))             // Skip any read-only properties
            {
                var originalValue = property.GetValue(this, null);
                property.SetValue(clone, originalValue, null);
            }

            // Deep-clone SharedItems
            if (SharedItems != null)
            {
                clone.SharedItems = SharedItems.Select(node => node.DeepCloneUnderParent(null, true)).ToList();
            }

            // Deep-clone Parts
            if (Parts != null)
            {
                clone.Parts = Parts.Select(node => node.DeepCloneUnderParent(null, true)).ToList();
                SpecifyParentsAndReferences(clone.Parts, clone.SharedItems);
            }

            // Clone Publications
            if (Publications != null)
            {
                clone.Publications = new List <string>(Publications);
            }

            return(clone);
        }
 public int CountDictionaryEntries(DictionaryConfigurationModel config)
 {
     int[] entries;
     using (ClerkActivator.ActivateClerkMatchingExportType(DictionaryType, m_mediator))
         ConfiguredXHTMLGenerator.GetPublicationDecoratorAndEntries(m_mediator, out entries, DictionaryType);
     return(entries.Count(e => IsGenerated(m_cache, config, e)));
 }
 private static bool IsAllReversalIndexConfig(DictionaryConfigurationModel configurationToDelete)
 {
     if (Path.GetFileNameWithoutExtension(configurationToDelete.FilePath) == "AllReversalIndexes")
     {
         return(true);
     }
     return(false);
 }
示例#14
0
 private void ClearValuesOnError()
 {
     ImportHappened                 = false;
     NewConfigToImport              = null;
     _originalConfigLabel           = null;
     _temporaryImportConfigLocation = null;
     _newPublications               = null;
 }
示例#15
0
 public void SelectConfiguration(DictionaryConfigurationModel configuration)
 {
     m_cbDictConfig.SelectedItem = configuration;
     if (treeControl.Tree.Nodes.Count > 0)
     {
         treeControl.Tree.Nodes[0].Expand();
     }
 }
 /// <summary>Get list of publications using a dictionary configuration.</summary>
 internal List <string> GetPublications(DictionaryConfigurationModel dictionaryConfiguration)
 {
     if (dictionaryConfiguration == null)
     {
         throw new ArgumentNullException();
     }
     return(dictionaryConfiguration.Publications);
 }
示例#17
0
        public void ConstructorRejectsNulls()
        {
            var view  = new TestHeadwordNumbersView();
            var model = new DictionaryConfigurationModel();

            Assert.Throws <ArgumentNullException>(() => new HeadwordNumbersController(view, model, null));
            Assert.Throws <ArgumentNullException>(() => new HeadwordNumbersController(null, model, Cache));
            Assert.Throws <ArgumentNullException>(() => new HeadwordNumbersController(view, null, Cache));
        }
 public void ExportDictionaryContent(string xhtmlPath, DictionaryConfigurationModel configuration = null, IThreadedProgress progress = null)
 {
     using (ClerkActivator.ActivateClerkMatchingExportType(DictionaryType, m_mediator))
     {
         configuration = configuration ?? new DictionaryConfigurationModel(
             DictionaryConfigurationListener.GetCurrentConfiguration(m_mediator, "Dictionary"), m_cache);
         ExportConfiguredXhtml(xhtmlPath, configuration, DictionaryType, progress);
     }
 }
        /// <summary>
        /// Determines how many times the entry with the given HVO is generated for the given config (usually 0 or 1,
        /// but can be more if the entry matches more than one Minor Entry node)
        /// </summary>
        internal static bool IsGenerated(FdoCache cache, DictionaryConfigurationModel config, int hvo)
        {
            var entry = (ILexEntry)cache.ServiceLocator.GetObject(hvo);

            if (ConfiguredXHTMLGenerator.IsMainEntry(entry, config))
            {
                return(config.Parts[0].IsEnabled && (!entry.ComplexFormEntryRefs.Any() || ConfiguredXHTMLGenerator.IsListItemSelectedForExport(config.Parts[0], entry)));
            }
            return(entry.PublishAsMinorEntry && config.Parts.Skip(1).Any(part => ConfiguredXHTMLGenerator.IsListItemSelectedForExport(part, entry)));
        }
示例#20
0
 /// <summary>
 /// This method will copy configuration node values from newDefaultConfigs over the matching nodes in oldDefaultConfigs
 /// </summary>
 /// <remarks>Intended to be used only on defaults, not on data with user changes.</remarks>
 internal static DictionaryConfigurationModel LoadConfigWithCurrentDefaults(DictionaryConfigurationModel oldDefaultConfigs,
                                                                            DictionaryConfigurationModel newDefaultConfigs)
 {
     foreach (var partNode in oldDefaultConfigs.Parts)
     {
         OverwriteDefaultsWithMatchingNode(partNode, newDefaultConfigs.Parts);
     }
     oldDefaultConfigs.FilePath = newDefaultConfigs.FilePath;
     oldDefaultConfigs.Label    = newDefaultConfigs.Label;
     return(oldDefaultConfigs);
 }
        private void ExportConfiguredXhtml(string xhtmlPath, DictionaryConfigurationModel configuration, string exportType, IThreadedProgress progress)
        {
            int[] entriesToSave;
            var   publicationDecorator = ConfiguredXHTMLGenerator.GetPublicationDecoratorAndEntries(m_mediator, out entriesToSave, exportType);

            if (progress != null)
            {
                progress.Maximum = entriesToSave.Length;
            }
            ConfiguredXHTMLGenerator.SavePublishedHtmlWithStyles(entriesToSave, publicationDecorator, int.MaxValue, configuration, m_mediator, xhtmlPath, progress);
        }
        /// <summary>
        /// Whether a configuration is, or is a customization of, a shipped default configuration,
        /// such as the shipped Root-based, Lexeme-based, or Bartholomew configurations.
        /// </summary>
        public static bool IsConfigurationACustomizedShippedDefault(DictionaryConfigurationModel configuration, string defaultConfigDir)
        {
            if (configuration.FilePath == null)
            {
                return(false);
            }

            var defaultConfigurationFiles = FileUtils.GetFilesInDirectory(defaultConfigDir).Select(Path.GetFileName);

            var filename = Path.GetFileName(configuration.FilePath);

            return(defaultConfigurationFiles.Contains(filename));
        }
示例#23
0
        public void KnowsWhenIsAShippedDefault()
        {
            var configuration = new DictionaryConfigurationModel
            {
                Label    = "configuration",
                FilePath = Path.Combine("whateverdir", "Root" + DictionaryConfigurationModel.FileExtension)
            };

            // SUT
            var claimsToBeDerived = _controller.IsConfigurationACustomizedOriginal(configuration);

            Assert.That(claimsToBeDerived, Is.True, "Should have reported this as a shipped default configuration.");
        }
示例#24
0
        public void NotAShippedDefaultIfNullFilePath()
        {
            var configuration = new DictionaryConfigurationModel
            {
                Label    = "configuration",
                FilePath = null
            };

            // SUT
            var claimsToBeDerived = _controller.IsConfigurationACustomizedOriginal(configuration);

            Assert.That(claimsToBeDerived, Is.False, "Should not have reported this as a shipped default configuration.");
        }
示例#25
0
        public void ConstructorSetsDescriptionTextInView_Reversal()
        {
            var view  = new TestHeadwordNumbersView();
            var model = new DictionaryConfigurationModel {
                WritingSystem = "en", Label = "PrincePauper"
            };
            // ReSharper disable once UnusedVariable
            // SUT
            var testController = new HeadwordNumbersController(view, model, Cache);

            Assert.That(view.Description, Is.StringContaining("Reversal Index"), "Description should say current 'Reversal Index' configuration");
            Assert.That(view.Description, Is.StringContaining("PrincePauper"), "Description should include the current configuration label");
        }
示例#26
0
        public void ConstructorSetsDefaultWritingSystemInView()
        {
            var view  = new TestHeadwordNumbersView();
            var model = new DictionaryConfigurationModel {
                HomographConfiguration = new DictionaryHomographConfiguration {
                    HomographWritingSystem = "pt"
                }
            };
            // SUT
            var testController = new HeadwordNumbersController(view, model, Cache);

            Assert.That(view.HomographWritingSystem, Is.StringContaining("English"),
                        "The default writing system 'English' should be in the view when given HomographWritingSystem is missing.");
        }
示例#27
0
        public void ReversalOfInvalidLanguageIsNotACustomizedOriginal()
        {
            var configuration = new DictionaryConfigurationModel
            {
                Label         = "English",
                WritingSystem = "enz1a",
                FilePath      = Path.Combine("whateverdir", "enz1a" + DictionaryConfigurationModel.FileExtension)
            };

            // SUT
            var claimsToBeDerived = _controller.IsConfigurationACustomizedOriginal(configuration);

            Assert.That(claimsToBeDerived, Is.False, "Should have reported this as a shipped default configuration.");
        }
示例#28
0
        public void ReversalOfLanguageWithRegionIsACustomizedOriginal()
        {
            var configuration = new DictionaryConfigurationModel
            {
                Label         = "German (Algeria)",
                WritingSystem = "de-DZ",
                FilePath      = Path.Combine("whateverdir", "de-DZ" + DictionaryConfigurationModel.FileExtension)
            };

            // SUT
            var claimsToBeDerived = _controller.IsConfigurationACustomizedOriginal(configuration);

            Assert.That(claimsToBeDerived, Is.True, "Should have reported this as a shipped default configuration.");
        }
示例#29
0
        public void ReversalNotMatchingLanguageIsACustomizedOriginal()
        {
            var configuration = new DictionaryConfigurationModel
            {
                Label         = "English (copy)",
                WritingSystem = "en",
                FilePath      = Path.Combine("whateverdir", "English-Copy" + DictionaryConfigurationModel.FileExtension)
            };

            // SUT
            var claimsToBeDerived = _controller.IsConfigurationACustomizedOriginal(configuration);

            Assert.That(claimsToBeDerived, Is.False, "This is a copy and not a customized original and should have reported false.");
        }
示例#30
0
        public void ReversalCopyIsNotACustomizedOriginal()
        {
            var configuration = new DictionaryConfigurationModel
            {
                Label         = "English Copy",
                WritingSystem = "en",
                FilePath      = Path.Combine("whateverdir", "Copy of English" + DictionaryConfigurationModel.FileExtension)
            };

            // SUT
            var claimsToBeDerived = _controller.IsConfigurationACustomizedOriginal(configuration);

            Assert.That(claimsToBeDerived, Is.False, "Copy of a reversal should not claim to be a customized original");
        }