public GatherBySemanticDomainTask(
GatherBySemanticDomainConfig config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate,
TaskMemoryRepository taskMemoryRepository,
ILogger logger
) :
base(
config,
lexEntryRepository,
viewTemplate, taskMemoryRepository
)
{
ViewTemplate = viewTemplate;
Guard.AgainstNull(config, "config");
Guard.AgainstNull(viewTemplate, "viewTemplate");
_config = config;
_logger = logger;
_taskMemory = taskMemoryRepository.FindOrCreateSettingsByTaskId(config.TaskName);
_currentDomainIndex = -1;
_currentQuestionIndex = 0;
_words = null;
_semanticDomainField = viewTemplate.GetField(LexSense.WellKnownProperties.SemanticDomainDdp4);
var definitionWsId = viewTemplate.GetField(LexSense.WellKnownProperties.Definition).WritingSystemIds.First();
IWritingSystemDefinition writingSystemForDefinition = viewTemplate.WritingSystems.Get(definitionWsId);
Guard.AgainstNull(writingSystemForDefinition, "Definition input System");
DefinitionWritingSystem = writingSystemForDefinition;
}
public GatherWordListTask(IGatherWordListConfig config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate,
TaskMemoryRepository taskMemoryRepository)
: base(config, lexEntryRepository, viewTemplate, taskMemoryRepository)
{
_viewTemplate = viewTemplate;
Guard.AgainstNull(config.WordListFileName, "config.WordListFileName");
Guard.AgainstNull(config.WordListWritingSystemIdOfOldFlatWordList, "config.WordListWritingSystemIdOfOldFlatWordList");
Guard.AgainstNull(viewTemplate, "viewTemplate");
//enhance: this isn't really true anymore, as we're moving to wordpack (where it's the folder)
//for now, this is figure out more carefully in GetPathToUse
_usingLiftFile = ".lift" == Path.GetExtension(config.WordListFileName).ToLower();
_lexicalUnitWritingSystem =
viewTemplate.GetFirstNonVoiceWritingSystemForFieldOrThrow(Field.FieldNames.EntryLexicalForm.ToString());
_lexemeFormListFileName = config.WordListFileName;
_words = null;
_preferredPromptingWritingSystemId = config.WordListWritingSystemIdOfOldFlatWordList;
var f = viewTemplate.GetField(LexSense.WellKnownProperties.Definition);
Guard.AgainstNull(f, "No field for definition");
_definitionWritingSystemIds = f.WritingSystemIds;
f = viewTemplate.GetField(LexSense.WellKnownProperties.Gloss);
if (f != null)
{
_glossWritingSystemIds = f.WritingSystemIds;
}
else
{
_glossWritingSystemIds = new List <string>();
}
if (f != null && f.IsMeaningField)
{
_glossMeaningField = true;
_meaningWritingSystemIds = _glossWritingSystemIds;
}
else
{
_meaningWritingSystemIds = _definitionWritingSystemIds;
}
if (_meaningWritingSystemIds.Count > 0)
{
_preferredPromptingWritingSystemId = _meaningWritingSystemIds[0];
}
}
private void SetupPickerControlWritingSystems()
{
RegisterFieldWithPicker(Field.FieldNames.EntryLexicalForm.ToString());
// show definition instead of gloss if it is meaningfield
Field defn = _viewTemplate.GetField(LexSense.WellKnownProperties.Definition);
if ((defn == null) || defn.IsMeaningField == true)
{
RegisterFieldWithPicker(LexSense.WellKnownProperties.Definition); //Reversal
}
else
{
RegisterFieldWithPicker(LexSense.WellKnownProperties.Gloss); //Reversal
}
}
protected WordGatheringTaskBase(ITaskConfiguration config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate,
TaskMemoryRepository taskMemoryRepository)
: base(config,
lexEntryRepository, taskMemoryRepository)
{
if (viewTemplate == null)
{
throw new ArgumentNullException("viewTemplate");
}
_viewTemplate = viewTemplate;
_lexicalFormWritingSystem =
viewTemplate.GetDefaultWritingSystemForField(Field.FieldNames.EntryLexicalForm.ToString());
var glossField = _viewTemplate.GetField(LexSense.WellKnownProperties.Gloss);
if (glossField == null)
{
_glossMeaningField = false;
}
else
{
_glossMeaningField = glossField.IsMeaningField;
}
}
private void RegisterFieldWithPicker(string fieldName)
{
Field field = _viewTemplate.GetField(fieldName);
if (field != null)
{
if (field.WritingSystemIds.Count > 0)
{
IList <IWritingSystemDefinition> writingSystems =
BasilProject.Project.WritingSystemsFromIds(field.WritingSystemIds);
foreach (IWritingSystemDefinition writingSystem in writingSystems)
{
if (!WritingSystemExistsInPicker(writingSystem))
{
AddWritingSystemToPicker(writingSystem, field);
}
}
}
else
{
ErrorReport.NotifyUserOfProblem(
"There are no input systems enabled for the Field '{0}'",
field.FieldName);
}
}
}
public void CrossReferenceWithNFD_OutputIsNFC()
{
SfmTransformSettings settings = new SfmTransformSettings();
settings.SfmTagConversions = "";
settings.VernacularLanguageWritingSystemId = "bth";
settings.EnglishLanguageWritingSystemId = "en";
_addin.Settings = settings;
string contents =
string.Format(
@"<?xml version='1.0' encoding='utf-8'?>
<lift version='{0}'>
<entry id='{1}'
guid='d9c25d1f-d373-4995-9ffa-ae2cf650603c'>
<lexical-unit>
<form lang='bth'>
<text>{2}</text>
</form>
</lexical-unit>
</entry>
<entry id='men_ebc7bf16-d322-4c3c-a4fd-3efdf8164eef'
guid='ebc7bf16-d322-4c3c-a4fd-3efdf8164eef'>
<lexical-unit>
<form lang='bth'>
<text>men</text>
</form>
</lexical-unit>
<relation
ref='{3}'
type = 'confer' />
</entry>
</lift>" ,
Validator.LiftVersion, "m\u00EB_d9c25d1f-d373-4995-9ffa-ae2cf650603c", "m\u00EB", "me\u0308_d9c25d1f-d373-4995-9ffa-ae2cf650603c");
Console.WriteLine(contents);
ViewTemplate template = WeSayWordsProject.Project.DefaultViewTemplate;
template.GetField(Palaso.DictionaryServices.Model.LexEntry.WellKnownProperties.CrossReference).Enabled = true;
string result = GetResultFromAddin(contents);
Console.WriteLine(result);
Regex regex = new Regex(@"\\lf\ confer\ =\ (.+)_([0-9a-f\-]+)", RegexOptions.Compiled);
using (StringReader reader = new StringReader(result))
{
string line = reader.ReadLine();
while (line != null)
{
Assert.IsFalse(regex.IsMatch(line));
line = reader.ReadLine();
}
reader.Close();
}
Assert.IsTrue(result.Contains("\\lf confer = m\u00EB"));
Assert.IsFalse(result.Contains("\\lf confer = me\u0308_d9c25d1f-d373-4995-9ffa-ae2cf650603c"));
}
private void MissingInfoTaskConfigControl_Load(object sender, EventArgs e)
{
_field = _viewTemplate.GetField(Configuration.MissingInfoFieldName);
_matchWhenEmpty.Visible = _field.DataTypeName == Field.BuiltInDataType.MultiText.ToString();
_matchWhenEmptyLabel.Visible = _matchWhenEmpty.Visible;
_requiredToBeFilledIn.Visible = _matchWhenEmpty.Visible;
_requiredToBeFilledInLabel.Visible = _requiredToBeFilledIn.Visible;
_setupLabel.Visible = _matchWhenEmpty.Visible;
if (_matchWhenEmpty.Visible)
{
_field.WritingSystemsChanged += OnWritingSystemsChanged;
Configuration.WritingSystemIdChanged += OnWritingSystemsChanged;
Configuration.WritingSystemIdDeleted += OnWritingSystemsDeleted;
UpdateWritingSystemFilterControls();
}
}
// private bool _suspendNotificationOfNavigation=false;
public GatherWordListTask(IGatherWordListConfig config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate)
: base(config, lexEntryRepository, viewTemplate)
{
if (config.WordListFileName == null)
{
throw new ArgumentNullException("wordListFileName");
}
if (config.WordListWritingSystemId == null)
{
throw new ArgumentNullException("wordListWritingSystemId");
}
if (viewTemplate == null)
{
throw new ArgumentNullException("viewTemplate");
}
Field lexicalFormField =
viewTemplate.GetField(Field.FieldNames.EntryLexicalForm.ToString());
if (lexicalFormField == null || lexicalFormField.WritingSystemIds.Count < 1)
{
_lexicalUnitWritingSystem =
BasilProject.Project.WritingSystems.UnknownVernacularWritingSystem;
}
else
{
string firstWSid = lexicalFormField.WritingSystemIds[0];
WritingSystem firstWS = BasilProject.Project.WritingSystems[firstWSid];
_lexicalUnitWritingSystem = firstWS;
}
_wordListFileName = config.WordListFileName;
_words = null;
_writingSystemIdForWordListWords = config.WordListWritingSystemId;
}
protected WordGatheringTaskBase(ITaskConfiguration config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate)
: base( config,
lexEntryRepository)
{
if (viewTemplate == null)
{
throw new ArgumentNullException("viewTemplate");
}
_viewTemplate = viewTemplate;
Field lexicalFormField =
viewTemplate.GetField(Field.FieldNames.EntryLexicalForm.ToString());
WritingSystemCollection writingSystems = BasilProject.Project.WritingSystems;
if (lexicalFormField == null || lexicalFormField.WritingSystemIds.Count < 1)
{
_lexicalFormWritingSystem = writingSystems.UnknownVernacularWritingSystem;
}
else
{
_lexicalFormWritingSystem = writingSystems[lexicalFormField.WritingSystemIds[0]];
}
}
public GatherBySemanticDomainTask(IGatherBySemanticDomainsConfig config,
LexEntryRepository lexEntryRepository,
ViewTemplate viewTemplate)
: base(
config,
lexEntryRepository,
viewTemplate)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (string.IsNullOrEmpty(config.semanticDomainsQuestionFileName))
{
throw new ArgumentNullException("config.semanticDomainsQuestionFileName");
}
if (viewTemplate == null)
{
throw new ArgumentNullException("viewTemplate");
}
_currentDomainIndex = -1;
_currentQuestionIndex = 0;
_words = null;
_semanticDomainQuestionsFileName =
DetermineActualQuestionsFileName(config.semanticDomainsQuestionFileName);
if (!File.Exists(_semanticDomainQuestionsFileName))
{
string pathInProject =
Path.Combine(
WeSayWordsProject.Project.PathToWeSaySpecificFilesDirectoryInProject,
_semanticDomainQuestionsFileName);
if (File.Exists(pathInProject))
{
_semanticDomainQuestionsFileName = pathInProject;
}
else
{
string pathInProgramDir = Path.Combine(BasilProject.ApplicationCommonDirectory,
_semanticDomainQuestionsFileName);
if (!File.Exists(pathInProgramDir))
{
throw new ApplicationException(
string.Format(
"Could not find the semanticDomainQuestions file {0}. Expected to find it at: {1} or {2}. The name of the file is influenced by the first enabled writing system for the Semantic Domain Field.",
_semanticDomainQuestionsFileName,
pathInProject,
pathInProgramDir));
}
_semanticDomainQuestionsFileName = pathInProgramDir;
}
}
_semanticDomainField = viewTemplate.GetField("SemanticDomainDdp4");
}
private static void AssertFieldLacksWritingSystem(ViewTemplate vt, string fieldName, string wsId)
{
var f = vt.GetField(fieldName);
Assert.IsFalse(f.WritingSystemIds.Contains(wsId));
}
private static void AssertFieldFirstWritingSystem(ViewTemplate vt, string fieldName, string wsId)
{
var f = vt.GetField(fieldName);
Assert.AreEqual(wsId, f.WritingSystemIds[0]);
}
