private void CreateLexentryWithOnlyCitationForm(string citationForm, string writingSystemId) { LexEntry entry = _lexEntryRepository.CreateItem(); entry.CitationForm[writingSystemId] = citationForm; _lexEntryRepository.SaveItem(entry); }
private void SaveAndCleanUpPreviousEntry() { LexEntry previousEntry = Control_EntryDetailPanel.DataSource; if (previousEntry != null) { previousEntry.PropertyChanged -= OnEntryChanged; if (!previousEntry.IsBeingDeleted) { _lexEntryRepository.SaveItem(previousEntry); } } }
public void ModifiedEntry_ByEntry_TriggersModifiedEntryAdded() { using (TemporaryFolder f = new TemporaryFolder("eventTests")) { using (LexEntryRepository r = new LexEntryRepository(f.GetPathForNewTempFile(true))) { LexEntry entry = r.CreateItem(); r.SaveItem(entry); r.AfterEntryModified += OnEvent; entry.Senses.Add(new LexSense()); r.SaveItem(entry); Assert.IsTrue(_gotEventCall); } } }
private Guid AddEntry(string lexemeForm, string meaningWritingSystemId, string meaning, bool includeExample) { LexEntry entry = _lexEntryRepository.CreateItem(); entry.LexicalForm.SetAlternative("th", lexemeForm); LexSense sense = new LexSense(); entry.Senses.Add(sense); #if GlossMeaning sense.Gloss[ WeSayWordsProject.Project.DefaultViewTemplate.GetField("SenseGloss").WritingSystemIds[0]] = meaning; #else sense.Definition.SetAlternative(meaningWritingSystemId, meaning); #endif if (includeExample) { LexExampleSentence ex = new LexExampleSentence(); sense.ExampleSentences.Add(ex); ex.Sentence.SetAlternative("th", "hello"); } _lexEntryRepository.SaveItem(entry); return(entry.Guid); }
private void SaveRecord() { if (_missingInfoControl != null && _missingInfoControl.CurrentEntry != null) { LexEntryRepository.SaveItem(_missingInfoControl.CurrentEntry); } }
//private void OnCreateNewLexEntry(object sender, // CreateNewArgs e) //{ // LexEntry newGuy = CreateNewLexEntry(e); // e.NewlyCreatedItem = newGuy; //} private void OnCreateNewPairStringLexEntryId(object sender, CreateNewArgs e) { LexEntry newGuy = CreateNewLexEntry(e); IWritingSystemDefinition writingSystem = GetWritingSystemFromField(); _lexEntryRepository.SaveItem(newGuy); _resultSet = _lexEntryRepository.GetAllEntriesSortedByLexicalFormOrAlternative(writingSystem); e.NewlyCreatedItem = GetRecordTokenFromLexEntry(newGuy); }
private LexEntry CreateEntryWithLexicalFormBeforeFirstQuery(string writingSystem, string lexicalForm) { LexEntry entryBeforeFirstQuery = _repository.CreateItem(); entryBeforeFirstQuery.LexicalForm.SetAlternative(writingSystem, lexicalForm); _repository.SaveItem(entryBeforeFirstQuery); return(entryBeforeFirstQuery); }
/// <summary> /// Adds this word and gloss, potentially adding the current semantic domain to multiple entriew with that word and gloss. /// </summary> /// <param name="lexicalForm"></param> /// <param name="gloss"></param> /// <returns>the entries that were modified </returns> public IList <LexEntry> AddWord(string lexicalForm, string gloss) { VerifyTaskActivated(); if (string.IsNullOrEmpty(lexicalForm)) { throw new ArgumentNullException(); } var modifiedEntries = new List <LexEntry>(); if (lexicalForm != string.Empty) { ResultSet <LexEntry> recordTokens = LexEntryRepository.GetEntriesWithMatchingLexicalForm(lexicalForm, FormWritingSystem); if (recordTokens.Count == 0) //no entries with a matching form { LexEntry entry = LexEntryRepository.CreateItem(); entry.LexicalForm.SetAlternative(WordWritingSystemId, lexicalForm); AddCurrentSemanticDomainToEntry(entry, gloss); LexEntryRepository.SaveItem(entry); modifiedEntries.Add(entry); _logger.WriteConciseHistoricalEvent("SD-Added '{0}' with Domain to '{1}'", entry.GetSimpleFormForLogging(), CurrentDomainName); } else // one or more matching entries { var entriesMatchingWord = new List <LexEntry>(from RecordToken <LexEntry> x in recordTokens select x.RealObject); foreach (var entry in entriesMatchingWord) { if (HasMatchingSense(entry, gloss)) { modifiedEntries.Add(entry); AddCurrentSemanticDomainToEntry(entry, gloss); _logger.WriteConciseHistoricalEvent("SD-Added Domain to '{0}'", entry.GetSimpleFormForLogging()); break; } } if (modifiedEntries.Count == 0) //didn't find any matching glosses { //NB: what to do IS NOT CLEAR. This just adds to the first entry, // but it's just rolling the dice! What to do??? var first = entriesMatchingWord.First(); modifiedEntries.Add(first); AddCurrentSemanticDomainToEntry(first, gloss); _logger.WriteConciseHistoricalEvent("SD-Added Domain {0} to '{1}' REVIEW", CurrentDomainName, first.GetSimpleFormForLogging()); } } } _savedSensesDuringMoveToEditArea = null; UpdateCurrentWords(); return(modifiedEntries); }
public void WordCollected_LexEntryAlreadyExists_WordAppearsInCompletedBox() { LexEntry e = _lexEntryRepository.CreateItem(); e.LexicalForm[VernWs.Id] = "uno"; Assert.AreEqual(1, _lexEntryRepository.CountAllItems()); MultiText word = new MultiText(); word[VernWs.Id] = "uno"; Assert.AreEqual(0, e.Senses.Count); _lexEntryRepository.SaveItem(e); Task.NavigateFirstToShow(); Task.WordCollected(word); Task.NavigateNext(); Task.WordCollected(word); ResultSet <LexEntry> matchingLexicalForms = Task.GetRecordsWithMatchingMeaning(); Assert.AreEqual(1, matchingLexicalForms.Count); Task.Deactivate(); }
private LexEntry CreateEntry(string lexemeForm, string meaning) { LexEntry entry = _lexEntryRepository.CreateItem(); entry.LexicalForm.SetAlternative(WritingSystemsIdsForTests.OtherIdForTest, lexemeForm); LexSense sense = new LexSense(); entry.Senses.Add(sense); sense.Gloss[ WeSayWordsProject.Project.DefaultViewTemplate.GetField( LexSense.WellKnownProperties.Definition).WritingSystemIds[0]] = meaning; _lexEntryRepository.SaveItem(entry); return(entry); }
private void CreateTestEntry(string lexicalForm, string Definition, string exampleSentence) { var entry = _lexEntryRepository.CreateItem(); entry.LexicalForm[_writingSystem.Id] = lexicalForm; var sense = new LexSense(); entry.Senses.Add(sense); sense.Definition[WritingSystemsIdsForTests.AnalysisIdForTest] = Definition; var example = new LexExampleSentence(); sense.ExampleSentences.Add(example); example.Sentence[_writingSystem.Id] = exampleSentence; _lexEntryRepository.SaveItem(entry); return; }
public void DeleteEntry_ByEntry_TriggersAfterEntryDeleted() { using (TemporaryFolder f = new TemporaryFolder("eventTests")) { using (LexEntryRepository r = new LexEntryRepository(f.GetPathForNewTempFile(true))) { r.AfterEntryDeleted += OnEvent; LexEntry entry = r.CreateItem(); r.SaveItem(entry); r.DeleteItem(entry); Assert.IsTrue(_gotEventCall); } } }
public void Setup() { _tempFolder = new TemporaryFolder(); _filePath = _tempFolder.GetTemporaryFile(); _lexEntryRepository = new LexEntryRepository(_filePath); WeSayProjectTestHelper.InitializeForTests(); RtfRenderer.HeadWordWritingSystemId = _vernacularWritingSystemId; _missingFieldName = LexSense.WellKnownProperties.Definition; LexEntry entry = _lexEntryRepository.CreateItem(); _lexicalForm = "vernacular"; entry.LexicalForm.SetAlternative(_vernacularWritingSystemId, _lexicalForm); _lexEntryRepository.SaveItem(entry); _longLabel = "Long label"; _remainingCountText = "Remaining count:"; _referenceCountText = "Reference count:"; _fieldsToShow = "LexicalForm"; _label = "My label"; _description = "My description"; _viewTemplate = new ViewTemplate(); _viewTemplate.Add(new Field(LexEntry.WellKnownProperties.LexicalUnit, "LexEntry", new string[] { _vernacularWritingSystemId })); _viewTemplate.Add(new Field(LexSense.WellKnownProperties.Definition, "LexSense", new string[] { "en" })); _viewTemplate.Add(new Field(Field.FieldNames.ExampleSentence.ToString(), "LexExampleSentence", new string[] { "th" })); _task = CreateMissingInfoTask(_lexEntryRepository, _missingFieldName, _label, _longLabel, _description, _remainingCountText, _referenceCountText, _viewTemplate, _fieldsToShow, string.Empty); }
private LexEntry CreateTestEntry(string lexicalForm, string meaning, string exampleSentence) { LexEntry entry = _lexEntryRepository.CreateItem(); entry.LexicalForm[GetSomeValidWsIdForField("EntryLexicalForm")] = lexicalForm; LexSense sense = new LexSense(); entry.Senses.Add(sense); #if GlossMeaning sense.Gloss[GetSomeValidWsIdForField("SenseGloss")] = meaning; #else sense.Definition[WritingSystemsIdsForTests.AnalysisIdForTest] = meaning; #endif LexExampleSentence example = new LexExampleSentence(); sense.ExampleSentences.Add(example); example.Sentence[GetSomeValidWsIdForField("ExampleSentence")] = exampleSentence; _lexEntryRepository.SaveItem(entry); return(entry); }
private string GetXhtmlContents(IList <LexEntry> entries) { if (entries != null) { entries.ForEach(e => _repo.SaveItem(e)); } var pliftbuilder = new StringBuilder(); using (var pexp = new PLiftExporter(pliftbuilder, false, _repo, _project.DefaultPrintingTemplate)) { ResultSet <LexEntry> recordTokens = _repo.GetAllEntriesSortedByHeadword(_project.DefaultPrintingTemplate.HeadwordWritingSystems[0]); foreach (RecordToken <LexEntry> token in recordTokens) { pexp.Add(token.RealObject); } pexp.End(); } var builder = new StringBuilder(); using (var w = new StringWriter(builder)) { var x = new FLExCompatibleXhtmlWriter(); // try { x.Write(new StringReader(pliftbuilder.ToString()), w); } // catch(Exception e) // { // Console.WriteLine(pliftbuilder.ToString()); // throw e; // } } return(builder.ToString()); }
private LexEntry CreateTestEntry(string lexicalForm, string meaning, string exampleSentence) { List <String> headwordWritingSystemIds = new List <string>(_viewTemplate.GetHeadwordWritingSystemIds()); string wsA = headwordWritingSystemIds[0]; string wsB = _viewTemplate.GetDefaultWritingSystemForField("definition").Id; LexEntry entry = _lexEntryRepository.CreateItem(); entry.LexicalForm[wsA] = lexicalForm; LexSense sense = new LexSense(); #if GlossMeaning sense.Gloss[GetSomeValidWsIdForField("SenseGloss")] = meaning; #else sense.Definition[wsB] = meaning; #endif LexExampleSentence example = new LexExampleSentence(); example.Sentence[wsA] = exampleSentence; sense.ExampleSentences.Add(example); entry.Senses.Add(sense); _lexEntryRepository.SaveItem(entry); return(entry); }
/// <summary> /// Removes the sense (if otherwise empty) and deletes the entry if it has no reason left to live /// </summary> public void TryToRemoveAssociationWithListWordFromEntry(RecordToken <LexEntry> recordToken) { // have to iterate through these in reverse order // since they might get modified LexEntry entry = recordToken.RealObject; for (int i = entry.Senses.Count - 1; i >= 0; i--) { if (entry.Senses[i].Equals(CurrentTemplateSense)) { entry.Senses.RemoveAt(i); } } entry.CleanUpAfterEditting(); if (entry.IsEmptyExceptForLexemeFormForPurposesOfDeletion) { LexEntryRepository.DeleteItem(entry); } else { LexEntryRepository.SaveItem(entry); } }
/// <summary> /// Try to add the sense to a matching entry. If none found, make a new entry with the sense /// </summary> private void AddSenseToLexicon(MultiTextBase lexemeForm, LexSense sense) { //remove from the gloss and def any forms we don't want in our project for those fields foreach (var form in sense.Gloss.Forms) { //why are we checking definition writing system here? Well, the whole gloss/def thing continues to be murky. When gathering, we're just //trying to populate both. And if you have your 1st def be, say, french, and don't have that in your glosses, well // in the WordList task, you won't see the words you gathered, because that's based on glosses! if (!_glossWritingSystemIds.Contains(form.WritingSystemId) && !_definitionWritingSystemIds.Contains(form.WritingSystemId)) { sense.Gloss.SetAlternative(form.WritingSystemId, null); } } foreach (var form in sense.Definition.Forms) { if (!_definitionWritingSystemIds.Contains(form.WritingSystemId) && !_glossWritingSystemIds.Contains(form.WritingSystemId)) { sense.Definition.SetAlternative(form.WritingSystemId, null); } } //I don't recall why we did this, but what it is doing is populating def from gloss and vice-versa, where there are blanks /* var definition = sense.Definition; * if(definition.Empty) * { * foreach (var form in sense.Gloss.Forms) * { * //this check makes sure we don't introduce a form form a lang we allow for gloss, but not def * if (_definitionWritingSystemIds.Contains(form.WritingSystemId)) * definition.SetAlternative(form.WritingSystemId, form.Form); * } * } * * var gloss = sense.Gloss; * if (gloss.Empty) * { * foreach (var form in sense.Definition.Forms) * { * //this check makes sure we don't introduce a form form a lang we allow for def, but not gloss * if (_glossWritingSystemIds.Contains(form.WritingSystemId)) * gloss.SetAlternative(form.WritingSystemId, form.Form); * } * } */ //review: the desired semantics of this find are unclear, if we have more than one ws ResultSet <LexEntry> entriesWithSameForm = LexEntryRepository.GetEntriesWithMatchingLexicalForm( lexemeForm[_lexicalUnitWritingSystem.Id], _lexicalUnitWritingSystem); var meaningField = _glossMeaningField ? sense.Gloss : sense.Definition; LanguageForm firstMeaning = new LanguageForm("en", "-none-", null); if (meaningField.Forms.Length > 0) { firstMeaning = meaningField.Forms[0]; } if (entriesWithSameForm.Count == 0) { LexEntry entry = LexEntryRepository.CreateItem(); entry.LexicalForm.MergeIn(lexemeForm); entry.Senses.Add(sense.Clone()); LexEntryRepository.SaveItem(entry); Logger.WriteEvent("WordList-Adding new word '{0}'and giving the sense '{1}'", entry.GetSimpleFormForLogging(), firstMeaning); } else { LexEntry entry = entriesWithSameForm[0].RealObject; foreach (LexSense s in entry.Senses) { if (meaningField.Forms.Length > 0) { LanguageForm meaningWeAreAdding = firstMeaning; string meaningInThisWritingSystem = _glossMeaningField ? s.Gloss.GetExactAlternative(meaningWeAreAdding.WritingSystemId) : s.Definition.GetExactAlternative(meaningWeAreAdding.WritingSystemId); if (meaningInThisWritingSystem == meaningWeAreAdding.Form) { Logger.WriteEvent("WordList '{0}' already exists in '{1}'", firstMeaning, entry.GetSimpleFormForLogging()); return; //don't add it again } } } if (sense.Gloss.Forms.Length == 0 && sense.Definition.Forms.Length == 0 && sense.ExampleSentences.Count == 0) { return; //nothing worth adding (may happen in unit test) } entry.Senses.Add(sense); //REVIEW: June 2011, Hatton added this, because of WS-34024: if a new *meaning* was added to an existing entry, //and then the user quit, this change was unsaved. LexEntryRepository.SaveItem(entry); Logger.WriteEvent("WordList-Added '{0}' to preexisting '{1}'", firstMeaning, entry.GetSimpleFormForLogging()); } }
private void AddCurrentSemanticDomainToEntry(LexEntry entry, string meaning) { LexSense sense = null; ////This can lead to wrongly assigned semantic domains in the case of multiple senses. Say I gather "shoot" in the "weapons" domain (no idea if that even exists but bear with me) ////then I gather "shoot" in the "plants" domain. Both domains would be assigned to the same sense. That being said I assume this approach was taken because it will USUALLY be ////what the user intends as homographs/multiple senses are not as frequent as one sense belonging to multiple domains (i.e. "Rain" could be "Universe/Creation", "Agriculture", ////"Times of year" etc etc.) --TA Oct/3/2012 //is the meaning empty? Then just grab the first sense if (ShowMeaningField && string.IsNullOrEmpty(meaning)) { sense = entry.Senses.FirstOrDefault(); } else { if ((_savedSensesDuringMoveToEditArea != null) && (_savedSensesDuringMoveToEditArea.Count > 0)) //we are editing a word we entered previously { //in this case, we have this saved sense we want to put back, //which could conceivably have example sentences and other stuff //so update the meaning in case they edited that if (ShowMeaningField) { _savedSensesDuringMoveToEditArea[0].Definition.SetAlternative(DefinitionWritingSystem.Id, meaning); } //are there senses with a matching glosses? foreach (var lexSense in _savedSensesDuringMoveToEditArea) { sense = entry.Senses.FirstOrDefault(s => s.Definition.ContainsEqualForm( lexSense.Definition[DefinitionWritingSystem.Id], DefinitionWritingSystem.Id)); if (sense != null) { //now, can we merge this sense in? if (!SenseMerger.TryMergeSenseWithSomeExistingSense(sense, lexSense, new string[] {}, new NullProgress())) { //ah well, they'll have to hand-merge at some point //Enhance: add a chorus note entry.Senses.Add(lexSense); } } else //ok, no matching sense to try and merge with, so just add this { entry.Senses.Add(lexSense); sense = lexSense; } } } else { //is there a sense with a matching gloss? sense = entry.Senses.FirstOrDefault(s => s.Definition.ContainsEqualForm(meaning, DefinitionWritingSystem.Id)); } } if (sense == null) { sense = entry.GetOrCreateSenseWithMeaning(new MultiText()); sense.Definition.SetAlternative(DefinitionWritingSystem.Id, meaning); } OptionRefCollection semanticDomains = sense.GetOrCreateProperty <OptionRefCollection>(_semanticDomainField.FieldName); if (!semanticDomains.Contains(CurrentDomainKey)) { semanticDomains.Add(CurrentDomainKey); } LexEntryRepository.SaveItem(entry); }
public void PrepareToMoveWordToEditArea(WordDisplay wordDisplay) { VerifyTaskActivated(); _savedSensesDuringMoveToEditArea = null; if (wordDisplay == null) { throw new ArgumentNullException(); } // this task was coded to have a list of word-forms, not actual entries. //so we have to go searching for possible matches at this point. ResultSet <LexEntry> matchingEntries = LexEntryRepository.GetEntriesWithMatchingLexicalForm(wordDisplay.Vernacular.Form, FormWritingSystem); foreach (RecordToken <LexEntry> recordToken in matchingEntries) { if (_savedSensesDuringMoveToEditArea == null) { _savedSensesDuringMoveToEditArea = new List <LexSense>(); } // have to iterate through these in reverse order since they might get modified LexEntry entry = recordToken.RealObject; //If we aren't showing the meaning field then we are going let any edits effect all matching Senses if (!ShowMeaningField) { for (int i = entry.Senses.Count - 1; i >= 0; i--) { LexSense sense = entry.Senses[i]; var semanticDomains = sense.GetProperty <OptionRefCollection>(_semanticDomainField.FieldName); if (semanticDomains != null) { if (semanticDomains.Contains(CurrentDomainKey)) { RememberMeaningOfDissociatedWord(sense); entry.Senses.Remove(sense); //if we don't do this and it has a meaning, we'll fail to delete the word when the user is trying to correct the spelling. (WS-34245) } } } } //If we are showing the meaning field then we only let edits effect the sense that matches the shown meaning (definition) else { var firstSenseMatchingSemDomAndMeaning = entry.Senses. Where(s => s.GetProperty <OptionRefCollection>(LexSense.WellKnownProperties.SemanticDomainDdp4) != null). FirstOrDefault(s => s.GetProperty <OptionRefCollection>(LexSense.WellKnownProperties.SemanticDomainDdp4).Contains(CurrentDomainKey) && s.Definition.GetBestAlternative(new[] { DefinitionWritingSystem.Id }) == wordDisplay.Meaning); if (firstSenseMatchingSemDomAndMeaning != null) { RememberMeaningOfDissociatedWord(firstSenseMatchingSemDomAndMeaning); entry.Senses.Remove(firstSenseMatchingSemDomAndMeaning); } } entry.CleanUpAfterEditting(); if (entry.IsEmptyExceptForLexemeFormForPurposesOfDeletion) { LexEntryRepository.DeleteItem(entry); // if there are no senses left, get rid of it } else { LexEntryRepository.SaveItem(entry); } } UpdateCurrentWords(); }