/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates a <see cref="ScrImportFileInfo"/> based on a file. This is used to build an
/// in-memory list of files.
/// </summary>
/// <param name="fileName">Name of the file whose info this represents</param>
/// <param name="mappingList">Sorted list of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="wsId">The writing system identifier of the source to which this file
/// belongs (null for Scripture source)</param>
/// <param name="noteType">The CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
public virtual IScrImportFileInfo Create(string fileName, ScrMappingList mappingList,
ImportDomain domain, string wsId, ICmAnnotationDefn noteType,
bool scanInlineBackslashMarkers)
{
return(new ScrImportFileInfo(fileName, mappingList, domain, wsId, noteType,
scanInlineBackslashMarkers));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Resets the in use flags to false for all mappings in the list.
/// Use this for non-Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain</param>
/// <param name="icuLocale">ICU locale of the import source</param>
/// <param name="hvoNoteType">ID of the default note type for the import source</param>
/// ------------------------------------------------------------------------------------
internal void ResetInUseFlags(ImportDomain importDomain, string icuLocale, int hvoNoteType)
{
foreach (ImportMappingInfo mapping in m_list.Values)
{
mapping.SetIsInUse(importDomain, icuLocale, hvoNoteType, false);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Resets the in use flags to false for all mappings in the list.
/// Use this for Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain</param>
/// ------------------------------------------------------------------------------------
internal void ResetInUseFlags(ImportDomain importDomain)
{
foreach (ImportMappingInfo mapping in m_list.Values)
{
mapping.SetIsInUse(importDomain, false);
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a ScrImportFileInfo from a CmFile. This is used when populating the
/// file list from the database.
/// </summary>
/// <param name="file">The CmFile</param>
/// <param name="mappingList">List of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="wsId">The ICU locale of the source to which this file belongs
/// (null for Scripture source)</param>
/// <param name="noteType">The CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
internal ScrImportFileInfo(ICmFile file, ScrMappingList mappingList, ImportDomain domain,
string wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers) :
this(file.AbsoluteInternalPath, mappingList, domain, wsId, noteType,
scanInlineBackslashMarkers)
{
m_file = file;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="ScrSfFileList"/> class based on an
/// existing ScrImportSFFiles in the DB.
/// </summary>
/// <param name="source">A DB-based collection of Standard Format files</param>
/// <param name="mappingList">The mapping list to which mappings will be added if any
/// new ones are found when scanning the files</param>
/// <param name="importDomain">Main (vernacular Scripture), BT or Annotations</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
public ScrSfFileList(IScrImportSFFiles source, ScrMappingList mappingList,
ImportDomain importDomain, bool scanInlineBackslashMarkers)
: this(null)
{
var deleteList = new List <ICmFile>();
// Load the files into an in-memory list
foreach (ICmFile file in source.FilesOC)
{
try
{
IScrImportFileInfo info = new ScrImportFileInfo(file, mappingList, importDomain,
source.WritingSystem, source.NoteTypeRA, scanInlineBackslashMarkers);
Add(info);
}
catch (ScriptureUtilsException e)
{
var userAction = source.Services.GetInstance <IFdoUI>();
userAction.DisplayMessage(MessageType.Error, string.Format(ScrFdoResources.kstidImportBadFile, e.Message), Strings.ksErrorCaption, e.HelpTopic);
deleteList.Add(file);
}
}
// delete all of the files that caused errors
foreach (ICmFile deleteItem in deleteList)
{
source.FilesOC.Remove(deleteItem);
}
m_modified = false;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a ScrImportFileInfo from a CmFile. This is used when populating the
/// file list from the database.
/// </summary>
/// <param name="file">The CmFile</param>
/// <param name="mappingList">List of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="icuLocale">The ICU locale of the source to which this file belongs
/// (null for Scripture source)</param>
/// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
public ScrImportFileInfo(ICmFile file, ScrMappingList mappingList, ImportDomain domain,
string icuLocale, int noteTypeHvo, bool scanInlineBackslashMarkers) :
this(file.AbsoluteInternalPath, mappingList, domain, icuLocale, noteTypeHvo,
scanInlineBackslashMarkers)
{
m_file = file;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="ScrSfFileList"/> class based on an
/// existing ScrImportSFFiles in the DB.
/// </summary>
/// <param name="source">A DB-based collection of Standard Format files</param>
/// <param name="mappingList">The mapping list to which mappings will be added if any
/// new ones are found when scanning the files</param>
/// <param name="importDomain">Main (vernacular Scripture), BT or Annotations</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// <param name="helpFile">The path of the application help file.</param>
/// ------------------------------------------------------------------------------------
public ScrSfFileList(ScrImportSFFiles source, ScrMappingList mappingList,
ImportDomain importDomain, bool scanInlineBackslashMarkers, string helpFile) : this(null)
{
List <int> deleteList = new List <int>();
// Load the files into an in-memory list
foreach (ICmFile file in source.FilesOC)
{
try
{
ScrImportFileInfo info = new ScrImportFileInfo(file, mappingList, importDomain,
source.ICULocale, source.NoteTypeRAHvo, scanInlineBackslashMarkers);
Add(info);
}
catch (ScriptureUtilsException e)
{
MessageBox.Show(string.Format(ScrFdoResources.kstidImportBadFile, e.Message), "", MessageBoxButtons.OK,
MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, 0, helpFile, HelpNavigator.Topic, e.HelpTopic);
deleteList.Add(file.Hvo);
}
}
// delete all of the files that caused errors
foreach (int deleteItem in deleteList)
{
source.Cache.DeleteObject(deleteItem);
}
m_modified = false;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a DummyScrImportFileInfo.
/// </summary>
/// <param name="fileName">Name of the file whose info this represents</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="icuLocale">The ICU locale of the source to which this file belongs
/// (null for Scripture source)</param>
/// <param name="noteType">The CmAnnotationDefn of the source to which this file belongs
/// (only used for Note sources)</param>
/// <param name="booksInFile">A list of integers representing 1-based canonical book
/// numbers that are in this file</param>
/// <param name="fileEncoding">The file encoding</param>
/// <param name="startRef">The first reference encountered in the file</param>
/// ------------------------------------------------------------------------------------
public DummyScrImportFileInfo(string fileName, ImportDomain domain, string icuLocale,
ICmAnnotationDefn noteType, List<int> booksInFile, Encoding fileEncoding, ScrReference startRef) :
base(fileName, null, domain, icuLocale, noteType, false)
{
m_booksInFile = booksInFile;
m_fileEncoding = fileEncoding;
m_startRef = startRef;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a DummyScrImportFileInfo.
/// </summary>
/// <param name="fileName">Name of the file whose info this represents</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="icuLocale">The ICU locale of the source to which this file belongs
/// (null for Scripture source)</param>
/// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// <param name="booksInFile">A list of integers representing 1-based canonical book
/// numbers that are in this file</param>
/// <param name="fileEncoding">The file encoding</param>
/// <param name="startRef">The first reference encountered in the file</param>
/// ------------------------------------------------------------------------------------
public DummyScrImportFileInfo(string fileName, ImportDomain domain, string icuLocale,
int noteTypeHvo, List <int> booksInFile, Encoding fileEncoding, ScrReference startRef) :
base(fileName, null, domain, icuLocale, noteTypeHvo, false)
{
m_booksInFile = booksInFile;
m_fileEncoding = fileEncoding;
m_startRef = startRef;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="T:SegmentInfo"/> class.
/// </summary>
/// <param name="sMarker">The segment marker.</param>
/// <param name="sText">The segment text.</param>
/// <param name="domain">The import domain.</param>
/// <param name="reference">The current Scripture reference.</param>
/// <param name="ws">The writing system (-1 to indicate the default WS).</param>
/// ------------------------------------------------------------------------------------
internal SegmentInfo(string sMarker, string sText, ImportDomain domain,
BCVRef reference, int ws)
{
m_sMarker = sMarker;
m_sText = sText;
m_domain = domain;
m_ref = reference;
m_ws = ws;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the P6 notes project if it is specified and is to be included
/// </summary>
/// ------------------------------------------------------------------------------------
protected bool LoadParatextNotesProject()
{
if (m_settings.ParatextNotesProj == null || !m_settings.ImportAnnotations)
{
return(false);
}
m_currentDomain = ImportDomain.Annotations;
LoadParatextProject(m_settings.ParatextNotesProj);
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the P6 vernacular project if it is specified and is to be included
/// </summary>
/// ------------------------------------------------------------------------------------
protected bool LoadParatextVernacularProject()
{
if (m_settings.ParatextScrProj == null)
{
return(false);
}
m_currentDomain = ImportDomain.Main;
LoadParatextProject(m_settings.ParatextScrProj);
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the P6 Back translation project if it is specified and is to be included
/// </summary>
/// ------------------------------------------------------------------------------------
protected bool LoadParatextBackTranslationProject()
{
if (m_settings.ParatextBTProj == null ||
!(m_settings.ImportBackTranslation || m_settings.ImportAnnotations))
{
return(false);
}
m_currentDomain = ImportDomain.BackTrans;
LoadParatextProject(m_settings.ParatextBTProj);
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a ScrImportFileInfo based on a filename. This is used to build an
/// in-memory list of files.
/// </summary>
/// <param name="fileName">Name of the file whose info this represents</param>
/// <param name="mappingList">Sorted list of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="icuLocale">The ICU locale of the source to which this file belongs
/// (null for Scripture source)</param>
/// <param name="noteTypeHvo">The HVO of the CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
public ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain,
string icuLocale, int noteTypeHvo, bool scanInlineBackslashMarkers)
{
m_fileName = fileName;
m_mappingList = mappingList;
m_domain = domain;
m_icuLocale = icuLocale;
m_noteTypeHvo = noteTypeHvo;
m_doStrictFileChecking = false;
ScanInlineBackslashMarkers = scanInlineBackslashMarkers;
Initialize();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a ScrImportFileInfo based on a filename. This is used to build an
/// in-memory list of files.
/// </summary>
/// <param name="fileName">Name of the file whose info this represents</param>
/// <param name="mappingList">Sorted list of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="wsId">The writing system identifier of the source to which this file
/// belongs (null for Scripture source)</param>
/// <param name="noteType">The CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
public ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain,
string wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers)
{
m_fileName = fileName;
m_mappingList = mappingList;
m_domain = domain;
m_wsId = wsId;
m_noteType = noteType;
m_doStrictFileChecking = false;
ScanInlineBackslashMarkers = scanInlineBackslashMarkers;
Initialize();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Mega constructor with style name
/// </summary>
/// ------------------------------------------------------------------------------------
public ImportMappingInfo(string beginMarker, string endMarker, bool isExcluded,
MappingTargetType mappingTarget, MarkerDomain domain, string styleName,
string wsId, ICmAnnotationDefn noteType, bool isInUse, ImportDomain importDomain)
{
m_beginMarker = beginMarker;
m_endMarker = endMarker;
m_isExcluded = isExcluded;
m_mappingTarget = mappingTarget;
m_domain = domain;
m_styleName = styleName;
m_style = null;
m_wsId = wsId;
m_noteType = noteType;
if (isInUse)
{
m_inUse[ScriptureServices.CreateImportSourceKey(importDomain, wsId,
noteType)] = isInUse;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="SCTextEnum"/> class.
/// </summary>
/// <param name="settings">The import settings</param>
/// <param name="domain">The source domain</param>
/// <param name="startRef">first reference to retrieve</param>
/// <param name="endRef">last reference to retrieve</param>
/// ------------------------------------------------------------------------------------
public SCTextEnum(IScrImportSet settings, ImportDomain domain,
BCVRef startRef, BCVRef endRef)
{
m_settings = settings;
m_domain = domain;
m_startRef = new BCVRef(startRef);
m_endRef = new BCVRef(endRef);
m_mappingSet = ((ScrImportSet)m_settings).GetMappingSetForDomain(domain);
// Gets the set of encoding converters
m_encConverters = new EncConverters();
// make a list of all of the begin and end markers for inline markers
// Also build the map of encoding converters
m_InlineBeginAndEndMarkers = new List <string>();
foreach (ImportMappingInfo mapping in ((ScrImportSet)m_settings).GetMappingListForDomain(domain))
{
if (mapping.IsInline || m_settings.ImportTypeEnum == TypeOfImport.Paratext5)
{
m_InlineBeginAndEndMarkers.Add(mapping.BeginMarker);
if (mapping.IsInline)
{
m_InlineBeginAndEndMarkers.Add(mapping.EndMarker);
}
}
}
m_InlineBeginAndEndMarkers.Sort(new LengthComparer());
// Build a list of all of the characters that inline markers start with
Set <char> tempCharList = new Set <char>();
foreach (string marker in m_InlineBeginAndEndMarkers)
{
tempCharList.Add(marker[0]); // Set ignores duplicates.
}
m_InlineMarkerStartChars = tempCharList.ToArray();
// Get the import file source that will provide the files to import.
m_importSource = ((ScrImportSet)settings).GetImportFiles(domain);
m_importSourceEnum = m_importSource.GetEnumerator();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="SCTextEnum"/> class.
/// </summary>
/// <param name="settings">The import settings</param>
/// <param name="domain">The source domain</param>
/// <param name="startRef">first reference to retrieve</param>
/// <param name="endRef">last reference to retrieve</param>
/// <param name="encConverters">The encoding converters repository</param>
/// ------------------------------------------------------------------------------------
public SCTextEnum(IScrImportSet settings, ImportDomain domain,
BCVRef startRef, BCVRef endRef, IEncConverters encConverters)
{
m_settings = settings;
m_domain = domain;
m_startRef = new BCVRef(startRef);
m_endRef = new BCVRef(endRef);
m_mappingSet = m_settings.GetMappingSetForDomain(domain);
// Gets the set of encoding converters
m_encConverters = encConverters;
// make a list of all of the begin and end markers for inline markers
// Also build the map of encoding converters
m_InlineBeginAndEndMarkers = new List<string>();
foreach (ImportMappingInfo mapping in m_settings.GetMappingListForDomain(domain))
{
if (mapping.IsInline || m_settings.ImportTypeEnum == TypeOfImport.Paratext5)
{
m_InlineBeginAndEndMarkers.Add(mapping.BeginMarker);
if (mapping.IsInline)
m_InlineBeginAndEndMarkers.Add(mapping.EndMarker);
}
}
m_InlineBeginAndEndMarkers.Sort(new StrLengthComparer(false));
// Build a list of all of the characters that inline markers start with
Set<char> tempCharList = new Set<char>();
foreach (string marker in m_InlineBeginAndEndMarkers)
tempCharList.Add(marker[0]); // Set ignores duplicates.
m_InlineMarkerStartChars = tempCharList.ToArray();
// Get the import file source that will provide the files to import.
m_importSource = settings.GetImportFiles(domain);
m_importSourceEnum = m_importSource.GetEnumerator();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Mega constructor with style name
/// </summary>
/// ------------------------------------------------------------------------------------
public ImportMappingInfo(string beginMarker, string endMarker, bool isExcluded,
MappingTargetType mappingTarget, MarkerDomain domain, string styleName,
string wsId, ICmAnnotationDefn noteType, bool isInUse, ImportDomain importDomain)
{
m_beginMarker = beginMarker;
m_endMarker = endMarker;
m_isExcluded = isExcluded;
m_mappingTarget = mappingTarget;
m_domain = domain;
m_styleName = styleName;
m_style = null;
m_wsId = wsId;
m_noteType = noteType;
if (isInUse)
{
m_inUse[ScriptureServices.CreateImportSourceKey(importDomain, wsId,
noteType)] = isInUse;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets flag to indicate whether this mapping's begin marker is in use in the given
/// import domain -- Use this version only for Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain</param>
/// <param name="value"><c>true</c> if the marker is in use</param>
/// ------------------------------------------------------------------------------------
public void SetIsInUse(ImportDomain importDomain, bool value)
{
m_inUse[importDomain] = value;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Add a default mapping for the given Standard Format marker if it does not exist yet.
/// </summary>
/// <param name="marker">The SF marker</param>
/// <param name="endMarker">The end marker (or null)</param>
/// <param name="importDomain">The import domain from which this marker originates</param>
/// <param name="fAutoMapBtMarkers">Indicates whether markers beginning with "bt" should
/// be treated as back-translation markers if possible.</param>
/// <param name="isInUse">Indicates whether this marker is actually in use in one or more
/// of the import files (for P6, this is currently always false since we're getting the
/// markers from the STY file -- we come back in a second pass and set it to true if we
/// find it in a file).</param>
/// <returns>The newly added mapping info, or the existing one if already in the list
/// </returns>
/// ------------------------------------------------------------------------------------
public ImportMappingInfo AddDefaultMappingIfNeeded(string marker, string endMarker,
ImportDomain importDomain, bool fAutoMapBtMarkers, bool isInUse)
{
// Look for the marker - if it is found, then we are done
if (this[marker] != null)
{
return(this[marker]);
}
// Read the TEStyles XML file to generate a table of mappings
if (s_defaultMappings.Count == 0)
{
ReadDefaultMappings();
}
string styleName;
bool excluded;
MappingTargetType target;
MarkerDomain markerDomain = (importDomain != ImportDomain.BackTrans) ?
MarkerDomain.Default : MarkerDomain.BackTrans;
if (importDomain == ImportDomain.Annotations)
{
// TODO (TE-5004): Map \rem (and possibly other markers?) automatically in annotations
// domain. Probably need to have a separate import mapping set in TeStyles.xml that has
// default mappings for the Annotations domain.
styleName = null;
excluded = s_defaultExclusions.ContainsKey(marker); //Make sure to check exclusions (TE-5703)
target = MappingTargetType.TEStyle;
}
else if (!GetDefaultMapping(marker, out styleName, out excluded, out target, ref markerDomain))
{
if (fAutoMapBtMarkers && importDomain == ImportDomain.Main &&
marker.StartsWith(@"\bt") && marker != @"\btc")
{
// pick out the corresponding vernacular marker. "\btblah" -> "\blah"
string correspondingVernMarker = marker.Remove(1, 2);
// if domain is DeprecatedScripture and the corresponding vernacular marker is defined...
ImportMappingInfo correspondingVernMarkerInfo = this[correspondingVernMarker];
if (correspondingVernMarkerInfo != null &&
(correspondingVernMarkerInfo.Domain & MarkerDomain.DeprecatedScripture) != 0)
{
// clear the DeprecatedScripture bit.
correspondingVernMarkerInfo.Domain ^= MarkerDomain.DeprecatedScripture;
}
if (correspondingVernMarkerInfo != null)
{
// If the corresponding vernacular marker is already defined...
if (correspondingVernMarkerInfo.Domain != MarkerDomain.Note &&
(correspondingVernMarkerInfo.Domain & MarkerDomain.BackTrans) == 0 &&
(correspondingVernMarkerInfo.MappingTarget != MappingTargetType.TEStyle ||
correspondingVernMarkerInfo.StyleName != null))
{
styleName = correspondingVernMarkerInfo.StyleName;
target = correspondingVernMarkerInfo.MappingTarget;
markerDomain = correspondingVernMarkerInfo.Domain;
// We only want to map to the BackTrans domain when mapping to a paragraph
// style because character styles automatically assume the domain of their
// containing paragraphs.
if (m_stylesheet == null || styleName == null ||
m_stylesheet.GetType(styleName) == (int)StyleType.kstParagraph)
{
markerDomain |= MarkerDomain.BackTrans;
}
}
}
else if (GetDefaultMapping(correspondingVernMarker, out styleName, out excluded, out target,
ref markerDomain))
{
// The corresponding vernacular marker has default mapping info so make this marker
// a back translation of it - unless it is an annotation or BT.
if (markerDomain == MarkerDomain.Note || markerDomain == MarkerDomain.BackTrans)
{
styleName = null;
excluded = false;
target = MappingTargetType.TEStyle;
markerDomain = MarkerDomain.Default;
}
else
{
markerDomain |= MarkerDomain.BackTrans;
}
}
}
}
// Create a mapping for the marker using the default mapping
ImportMappingInfo newMapping = new ImportMappingInfo(marker, endMarker, excluded, target,
markerDomain, styleName, null, null, isInUse, importDomain);
Add(newMapping);
return(newMapping);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a ScrImportFileInfo from a CmFile owned by a BT source. This is
/// used when populating the file list from the database.
/// </summary>
/// <param name="file">The CmFile</param>
/// <param name="mappingList">Sorted list of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="wsId">The ICU locale of the source to which this file belongs
/// (null for Scripture source)</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
internal ScrImportFileInfo(ICmFile file, ScrMappingList mappingList, ImportDomain domain,
string wsId, bool scanInlineBackslashMarkers) :
this(file, mappingList, domain, wsId, null, scanInlineBackslashMarkers)
{
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Calls the FinalizePrevSection() method.
/// </summary>
/// ------------------------------------------------------------------------------------
internal void CallFinalizePrevSection(IScrSection section,
ImportDomain prevImportDomain, bool fInScriptureText)
{
m_currSection = section;
m_prevImportDomain = prevImportDomain;
m_fInScriptureText = fInScriptureText;
m_fCurrentSectionIsIntro = section.IsIntro;
m_sectionHeading = section.HeadingOA;
m_sectionContent = section.ContentOA;
FinalizePrevSection();
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="SCScriptureText"/> class.
/// </summary>
/// <param name="settings">The import settings</param>
/// <param name="domain">The source domain</param>
/// ------------------------------------------------------------------------------------
public SCScriptureText(IScrImportSet settings, ImportDomain domain)
{
Debug.Assert(settings != null);
m_settings = settings;
m_domain = domain;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the mappings for a paratext project into the specified list.
/// </summary>
/// <param name="project">Paratext project ID</param>
/// <param name="mappingList">ScrMappingList to which new mappings will be added</param>
/// <param name="domain">The import domain for which this project is the source</param>
/// <returns><c>true</c> if the Paratext mappings were loaded successfully; <c>false</c>
/// otherwise</returns>
/// ------------------------------------------------------------------------------------
public static bool LoadParatextMappings(string project, ScrMappingList mappingList,
ImportDomain domain)
{
// If the new project ID is null, then do not load mappings.
if (project == null)
{
return(false);
}
// Load the tags from the paratext project and create mappings for them.
SCRIPTUREOBJECTSLib.ISCScriptureText3 scParatextText = null;
try
{
scParatextText = new SCRIPTUREOBJECTSLib.SCScriptureTextClass();
scParatextText.Load(project);
}
catch (Exception ex)
{
Logger.WriteEvent(string.Format(
"Got {0} exception loading paratext mappings (ScrImportP6Project.LoadParatextMappings):\n{1}",
ex.GetType(), ex.Message));
return(false);
}
// TE-5802
try
{
for (int i = 0; true; i++)
{
SCRIPTUREOBJECTSLib.ISCTag tag = scParatextText.NthTag(i);
if (tag == null)
{
break;
}
string marker = @"\" + tag.Marker;
string endMarker = string.Empty;
if (tag.Endmarker != string.Empty && tag.Endmarker != null)
{
endMarker = @"\" + tag.Endmarker;
}
// When the nth marker has an end marker, the nth + 1 marker will be
// that end marker. Therefore, we have to skip those "end style" markers.
if (tag.StyleType == SCRIPTUREOBJECTSLib.SCStyleType.scEndStyle)
{
continue;
}
// Create a new mapping for this marker.
mappingList.AddDefaultMappingIfNeeded(marker, endMarker, domain, false, false);
}
SCRIPTUREOBJECTSLib.SCReference startRefPT = new SCRIPTUREOBJECTSLib.SCReference();
SCRIPTUREOBJECTSLib.SCReference endRefPT = new SCRIPTUREOBJECTSLib.SCReference();
startRefPT.Parse("GEN 1:0");
endRefPT.Parse("REV 22:21");
SCRIPTUREOBJECTSLib.ISCTextEnum scParatextTextEnum = scParatextText.TextEnum(
(SCRIPTUREOBJECTSLib.SCReference)startRefPT, (SCRIPTUREOBJECTSLib.SCReference)endRefPT,
(SCRIPTUREOBJECTSLib.SCTextType) 0, //scTitle | scSection | scVerseText | scNoteText | scOther)
(SCRIPTUREOBJECTSLib.SCTextProperties) 0);
SCRIPTUREOBJECTSLib.SCTextSegment scParatextTextSegment = new SCRIPTUREOBJECTSLib.SCTextSegmentClass();
mappingList.ResetInUseFlags(domain);
while (scParatextTextEnum.Next(scParatextTextSegment) != 0)
{
string sMarker = @"\" + scParatextTextSegment.Tag.Marker;
ImportMappingInfo mapping = mappingList[sMarker];
if (mapping != null)
{
mapping.SetIsInUse(domain, true);
}
// ENHANCE (TE-4408): Consider Detecting markers that occur in the data but are missing
// from the STY file. How can we write a test for this?
//else if (ScrImportFileInfo.IsValidMarker(sMarker))
//{
// mappingList.AddDefaultMappingIfNeeded(sMarker,domain, false, true);
//}
//else
//{
// throw new ScriptureUtilsException(SUE_ErrorCode.InvalidCharacterInMarker, null, 0,
// sMarker + sText, new ScrReference(scParatextTextSegment.FirstReference.BBCCCVVV));
//}
}
}
catch (Exception ex)
{
Logger.WriteEvent(string.Format(
"Got {0} exception loading paratext mappings (ScrImportP6Project.LoadParatextMappings):\n{1}",
ex.GetType(), ex.Message));
return(false);
}
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets flag to indicate whether this mapping's begin marker is in use in the given
/// import domain -- Use this version only for Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain</param>
/// <param name="value"><c>true</c> if the marker is in use</param>
/// ------------------------------------------------------------------------------------
public void SetIsInUse(ImportDomain importDomain, bool value)
{
m_inUse[importDomain] = value;
}
private bool LoadProjectMappings(string project, ScrMappingList mappingList, ImportDomain domain)
{
// If the new project ID is null, then do not load mappings.
if (string.IsNullOrEmpty(project))
{
return(false);
}
// Load the tags from the paratext project and create mappings for them.
IScrText scParatextText;
try
{
// ParatextShared has a static collection that is responsible for the dispose of any IScrText objects
scParatextText = ScriptureProvider.Get(project);
}
catch (Exception ex)
{
Logger.WriteError(ex);
m_IsParatextInitialized = false;
return(false);
}
foreach (ImportMappingInfo mapping in mappingList)
{
mapping.SetIsInUse(domain, false);
}
try
{
foreach (var tag in scParatextText.DefaultStylesheet.Tags)
{
if (tag == null)
{
break;
}
string marker = @"\" + tag.Marker;
string endMarker = string.Empty;
if (!string.IsNullOrEmpty(tag.Endmarker))
{
endMarker = @"\" + tag.Endmarker;
}
// When the nth marker has an end marker, the nth + 1 marker will be
// that end marker. Therefore, we have to skip those "end style" markers.
if (tag.StyleType == ScrStyleType.scEndStyle)
{
continue;
}
// Create a new mapping for this marker.
mappingList.AddDefaultMappingIfNeeded(marker, endMarker, domain, false, false);
}
var parser = scParatextText.Parser;
foreach (int bookNum in scParatextText.BooksPresentSet.SelectedBookNumbers)
{
foreach (var token in parser.GetUsfmTokens(ScriptureProvider.MakeVerseRef(bookNum, 0, 0), false, true))
{
if (token.Marker == null)
{
continue; // Tokens alternate between text and marker types
}
ImportMappingInfo mapping = mappingList[@"\" + token.Marker];
if (mapping != null)
{
mapping.SetIsInUse(domain, true);
}
}
}
}
catch (Exception ex)
{
Logger.WriteError(ex);
// A lot goes on in the try block, so this exception doesn't necessarily mean Paratext is inaccessible,
// so don't mark Paratext as uninitialized
return(false);
}
return(true);
}
static void Main(string[] args)
{
var connectionString = "Host=localhost;Database=Test44;Username=postgres;Password=postgres";
//var b = ImportDomain.TestConnection(connectionString);
var rr = ImportDomain.GetRelations(connectionString);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Helper method to get a TextEnum ready to read
/// </summary>
/// ------------------------------------------------------------------------------------
private ISCTextEnum GetTextEnum(ImportDomain domain, BCVRef startRef, BCVRef endRef)
{
// Save settings before enumerating, which will get the styles hooked up in the mapping list
m_settings.SaveSettings();
SCScriptureText scText = new SCScriptureText(m_settings, domain);
return scText.TextEnum(startRef, endRef);
}
/// <summary></summary>
public DummySCScriptureText(ScrImportSet settings, ImportDomain domain):
base(settings, domain)
{
}
/// <summary></summary>
public DummySCTextEnum(IScrImportSet settings, ImportDomain domain,
BCVRef startRef, BCVRef endRef) :
base(settings, domain, startRef, endRef)
{
DynamicMock mockConverters = new DynamicMock(typeof(IEncConverters));
mockConverters.SetupResultForParams("Item", new DummyEncConverter(), "UPPERCASE");
m_encConverters = (IEncConverters)mockConverters.MockInstance;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the P6 vernacular project if it is specified and is to be included
/// </summary>
/// ------------------------------------------------------------------------------------
protected bool LoadParatextVernacularProject()
{
if (m_settings.ParatextScrProj == null)
return false;
m_currentDomain = ImportDomain.Main;
LoadParatextProject(m_settings.ParatextScrProj);
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the P6 notes project if it is specified and is to be included
/// </summary>
/// ------------------------------------------------------------------------------------
protected bool LoadParatextNotesProject()
{
if (m_settings.ParatextNotesProj == null || !m_settings.ImportAnnotations)
return false;
m_currentDomain = ImportDomain.Annotations;
LoadParatextProject(m_settings.ParatextNotesProj);
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets flag to indicate whether this mapping's begin marker is in use in the given
/// import source -- Use this version only for non-Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain of the source</param>
/// <param name="icuLocale">ICU locale of the import source</param>
/// <param name="noteType">The default note type for the import source</param>
/// <param name="value"><c>true</c> if the marker is in use</param>
/// ------------------------------------------------------------------------------------
public void SetIsInUse(ImportDomain importDomain, string icuLocale,
ICmAnnotationDefn noteType, bool value)
{
m_inUse[ScriptureServices.CreateImportSourceKey(importDomain, icuLocale, noteType)] = value;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets flag to indicate whether this mapping's begin marker is in use in the given
/// import source -- Use this version only for non-Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain of the source</param>
/// <param name="icuLocale">ICU locale of the import source</param>
/// <param name="hvoNoteType">ID of the default note type for the import source</param>
/// <param name="value"><c>true</c> if the marker is in use</param>
/// ------------------------------------------------------------------------------------
public void SetIsInUse(ImportDomain importDomain, string icuLocale, int hvoNoteType,
bool value)
{
m_inUse[ScrImportSet.CreateImportSourceKey(importDomain, icuLocale, hvoNoteType)] = value;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Mega constructor with style name
/// </summary>
/// ------------------------------------------------------------------------------------
public ImportMappingInfo(string beginMarker, string endMarker, bool isExcluded,
MappingTargetType mappingTarget, MarkerDomain domain, string styleName,
string icuLocale, ICmAnnotationDefn noteType, bool isInUse, ImportDomain importDomain)
{
m_beginMarker = beginMarker;
m_endMarker = endMarker;
m_isExcluded = isExcluded;
m_mappingTarget = mappingTarget;
m_domain = domain;
m_styleName = styleName;
m_style = null;
m_icuLocale = icuLocale;
m_noteType = noteType;
if (isInUse)
{
m_inUse[ScrImportSet.CreateImportSourceKey(importDomain, icuLocale,
noteType == null ? 0 : noteType.Hvo)] = isInUse;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Construct a ScrImportFileInfo based on a Toolbox (i.e., non-Paratext 5) filename.
/// This is used only in tests.
/// </summary>
/// <param name="fileName">Name of the file whose info this represents</param>
/// <param name="mappingList">Sorted list of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="wsId">The writing system identifier of the source to which this file
/// belongs (null for Scripture source)</param>
/// <param name="noteType">The CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// ------------------------------------------------------------------------------------
internal ScrImportFileInfo(string fileName, ScrMappingList mappingList, ImportDomain domain,
string wsId, ICmAnnotationDefn noteType)
: this(fileName, mappingList, domain, wsId, noteType, false)
{
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get the file list for the given domain, writing system identifier and note type.
/// </summary>
/// <param name="domain">The source domain</param>
/// <param name="wsId">The writing system identifier for the source (ignored for
/// scripture domain)</param>
/// <param name="noteType">The CmAnnotationDefn for the note type (ignored for back
/// trans and scripture domains)</param>
/// <param name="createListIfNeeded">True to create the list if it does not already
/// exist for a given writing system identifier and note type</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private ScrSfFileList GetFileList(ImportDomain domain, string wsId,
ICmAnnotationDefn noteType, bool createListIfNeeded)
{
Debug.Assert(ImportTypeEnum == TypeOfImport.Other || ImportTypeEnum == TypeOfImport.Paratext5);
if (wsId == null)
wsId = string.Empty;
switch (domain)
{
default:
case ImportDomain.Main:
return m_scrFileInfoList;
case ImportDomain.BackTrans:
{
// Look for a back trans source with the given writing system identifier.
ScrSfFileList btList = m_btFileInfoLists[wsId] as ScrSfFileList;
if (btList == null && createListIfNeeded)
{
btList = new ScrSfFileList(m_resolver);
m_btFileInfoLists[wsId] = btList;
}
return btList;
}
case ImportDomain.Annotations:
{
// Look for a annotations source with the given writing system identifier.
string key = ScriptureServices.CreateImportSourceKey(wsId, noteType);
ScrSfFileList noteList = m_notesFileInfoLists[key] as ScrSfFileList;
if (noteList == null && createListIfNeeded)
{
noteList = new ScrSfFileList(m_resolver);
m_notesFileInfoLists[key] = noteList;
}
return noteList;
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets an import file source that will provide all of the files for an import
/// </summary>
/// <param name="domain"></param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
public ImportFileSource GetImportFiles(ImportDomain domain)
{
lock (SyncRoot)
{
switch (domain)
{
case ImportDomain.Main:
return new ImportFileSource(m_scrFileInfoList);
case ImportDomain.BackTrans:
return new ImportFileSource(m_btFileInfoLists, m_cache);
case ImportDomain.Annotations:
return new ImportFileSource(m_notesFileInfoLists, m_cache);
default:
throw new ArgumentException("unexpected domain");
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Remove a file from the file list
/// </summary>
/// <param name="fileName"></param>
/// <param name="domain">The domain to remove the file from</param>
/// <param name="wsId">The writing system identifier for the source (ignored for
/// scripture domain)</param>
/// <param name="noteType">The CmAnnotationDefn for the note type (ignored for back
/// trans and scripture domains)</param>
/// ------------------------------------------------------------------------------------
public void RemoveFile(string fileName, ImportDomain domain, string wsId,
ICmAnnotationDefn noteType)
{
lock (SyncRoot)
{
ScrSfFileList fileList = GetFileList(domain, wsId, noteType, false);
if (fileList == null)
return;
foreach (IScrImportFileInfo info in fileList)
{
if (info.FileName.ToUpper() == fileName.ToUpper())
{
fileList.Remove(info);
if (fileList.Count == 0)
{
GetMappingListForDomain(domain).ResetInUseFlags(domain, wsId, noteType);
}
return;
}
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Add a default mapping for the given Standard Format marker if it does not exist yet.
/// </summary>
/// <param name="marker">The SF marker</param>
/// <param name="domain">The import domain from which this marker originates</param>
/// <param name="fAutoMapBtMarkers">Indicates whether markers beginning with "bt" should
/// be treated as back-translation markers if possible.</param>
/// <returns>The newly added mapping info, or the existing one if already in the list
/// </returns>
/// ------------------------------------------------------------------------------------
public ImportMappingInfo AddDefaultMappingIfNeeded(string marker, ImportDomain domain,
bool fAutoMapBtMarkers)
{
return(AddDefaultMappingIfNeeded(marker, null, domain, fAutoMapBtMarkers, true));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Creates a mocked <see cref="IScrImportFileInfo"/>. This is used to build an
/// in-memory list of files.
/// </summary>
/// <param name="fileName">Name of the file whose info this represents</param>
/// <param name="mappingList">Sorted list of mappings to which newly found mappings
/// should (and will) be added</param>
/// <param name="domain">The import domain to which this file belongs</param>
/// <param name="wsId">The writing system identifier of the source to which this file
/// belongs (null for Scripture source)</param>
/// <param name="noteType">The CmAnnotationDefn of the source to which
/// this file belongs (only used for Note sources)</param>
/// <param name="scanInlineBackslashMarkers"><c>true</c> to look for backslash markers
/// in the middle of lines. (Toolbox dictates that fields tagged with backslash markers
/// must start on a new line, but Paratext considers all backslashes in the data to be
/// SF markers.)</param>
/// ------------------------------------------------------------------------------------
public override IScrImportFileInfo Create(string fileName, ScrMappingList mappingList,
ImportDomain domain, string wsId, ICmAnnotationDefn noteType, bool scanInlineBackslashMarkers)
{
IScrImportFileInfo info = MockRepository.GenerateStub<IScrImportFileInfo>();
m_mockedScrImportFinfos[fileName] = info;
info.Stub(x => x.FileName).Return(fileName);
info.Stub(x => x.WsId).Return(wsId);
info.Stub(x => x.NoteType).Return(noteType);
return info;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Advance the scripture text object enumerator to the next segment.
/// </summary>
/// <remarks>Virtual to support testing</remarks>
/// <param name="sText">Set to the text of the current segment</param>
/// <param name="sMarker">Set to the marker of the current segment tag</param>
/// <param name="domain">Set to the domain of the stream being processed</param>
/// <returns>True if successful. False if there are no more segments.</returns>
/// ------------------------------------------------------------------------------------
public virtual bool GetNextSegment(out string sText, out string sMarker,
out ImportDomain domain)
{
int result = 0;
domain = m_currentDomain;
if (TypeOfImport == TypeOfImport.Paratext6)
{
result = m_scParatextTextEnum.Next(m_scParatextTextSegment);
if (result != 0)
{
sText = m_scParatextTextSegment.Text;
sMarker = @"\" + m_scParatextTextSegment.Tag.Marker;
if (!ScrImportFileInfo.IsValidMarker(sMarker))
{
throw new ScriptureUtilsException(SUE_ErrorCode.InvalidCharacterInMarker, null, 0,
sMarker + sText, m_scParatextTextSegment.FirstReference.BBCCCVVV);
}
return(true);
}
else
{
switch (m_currentDomain)
{
case ImportDomain.Main:
{
if (LoadParatextBackTranslationProject())
{
return(GetNextSegment(out sText, out sMarker, out domain));
}
goto case ImportDomain.BackTrans;
}
case ImportDomain.BackTrans:
{
if (LoadParatextNotesProject())
{
return(GetNextSegment(out sText, out sMarker, out domain));
}
break;
}
}
}
}
else if (TypeOfImport == TypeOfImport.Other || TypeOfImport == TypeOfImport.Paratext5)
{
m_scTextSegment = m_scTextEnum.Next();
if (m_scTextSegment != null)
{
sText = m_scTextSegment.Text;
sMarker = m_scTextSegment.Marker;
return(true);
}
else
{
switch (m_currentDomain)
{
case ImportDomain.Main:
{
m_currentDomain = ImportDomain.BackTrans;
m_scSfmText = new SCScriptureText(m_settings, ImportDomain.BackTrans);
// Now initialize the TextEnum with the range of scripture text we want
m_scTextEnum = m_scSfmText.TextEnum(m_settings.StartRef, m_settings.EndRef);
return(GetNextSegment(out sText, out sMarker, out domain));
}
case ImportDomain.BackTrans:
{
m_currentDomain = ImportDomain.Annotations;
m_scSfmText = new SCScriptureText(m_settings, ImportDomain.Annotations);
// Now initialize the TextEnum with the range of scripture text we want
m_scTextEnum = m_scSfmText.TextEnum(m_settings.StartRef, m_settings.EndRef);
return(GetNextSegment(out sText, out sMarker, out domain));
}
}
}
}
else
{
throw new Exception("GetNextSegment has an invalid import type");
}
sText = null;
sMarker = null;
return(false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Handle the start of book segments
/// </summary>
/// <returns><c>true if this segment was a book marker</c></returns>
/// ------------------------------------------------------------------------------------
private bool HandleStartOfBook()
{
// Start of Book (or possibly just another file with more of the same book)
if (m_context != ContextValues.Book)
return false;
int wsCurrentStream = SOWrapper.CurrentWs(m_wsOfPrevImportStream);
// If this is the first book, a new book, or a new domain...
if (!m_fFoundABook || m_nBookNumber != SOWrapper.SegmentFirstRef.Book ||
m_prevImportDomain != m_importDomain || m_wsOfPrevImportStream != wsCurrentStream)
{
ProcessStartOfBook();
m_nPrevBookNumber = m_nBookNumber;
m_fFoundABook = true;
if (m_prevImportDomain != m_importDomain)
{
// if we are starting a new domain, remove "rogue" import style proxies that have
// not been used.
foreach (string marker in m_unmappedMarkers)
if (m_styleProxies[marker].Style == null)
m_styleProxies.Remove(marker);
m_unmappedMarkers.Clear();
}
}
m_prevImportDomain = m_importDomain;
m_wsOfPrevImportStream = wsCurrentStream;
if (m_importDomain == ImportDomain.BackTrans)
{
m_fBackTransChapterNumPending = m_fBackTransVerseNumPending = false;
}
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets flag to indicate whether this mapping's begin marker is in use in the given
/// import source -- Use this version only for non-Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain of the source</param>
/// <param name="icuLocale">ICU locale of the import source</param>
/// <param name="noteType">The default note type for the import source</param>
/// <param name="value"><c>true</c> if the marker is in use</param>
/// ------------------------------------------------------------------------------------
public void SetIsInUse(ImportDomain importDomain, string icuLocale,
ICmAnnotationDefn noteType, bool value)
{
m_inUse[ScriptureServices.CreateImportSourceKey(importDomain, icuLocale, noteType)] = value;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="SCScriptureText"/> class.
/// </summary>
/// <param name="settings">The import settings</param>
/// <param name="domain">The source domain</param>
/// ------------------------------------------------------------------------------------
public SCScriptureText(IScrImportSet settings, ImportDomain domain)
{
Debug.Assert(settings != null);
m_settings = settings;
m_domain = domain;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Advance the scripture text object enumerator to the next segment.
/// </summary>
/// <remarks>Virtual to support testing</remarks>
/// <param name="sText">Set to the text of the current segment</param>
/// <param name="sMarker">Set to the marker of the current segment tag</param>
/// <param name="domain">Set to the domain of the stream being processed</param>
/// <returns>True if successful. False if there are no more segments.</returns>
/// ------------------------------------------------------------------------------------
public virtual bool GetNextSegment(out string sText, out string sMarker,
out ImportDomain domain)
{
domain = m_currentDomain;
if (TypeOfImport == TypeOfImport.Paratext6)
{
GetNextParatextSegment(out sText, out sMarker);
if (sMarker != null)
return true;
// We didn't get any segment so assume that we hit the end of the data for the book
// ENHANCE: When we support partial book imports, this needs to change.
m_ptCurrBook.BookNum++;
if (m_ptCurrBook.BookNum <= m_settings.EndRef.Book)
{
ResetParatextState();
return GetNextSegment(out sText, out sMarker, out domain);
}
// We hit the end of our import range so try the next import domain
m_ptCurrBook.BookNum = m_settings.StartRef.Book;
switch (m_currentDomain)
{
case ImportDomain.Main:
{
if (LoadParatextBackTranslationProject())
return GetNextSegment(out sText, out sMarker, out domain);
goto case ImportDomain.BackTrans;
}
case ImportDomain.BackTrans:
{
if (LoadParatextNotesProject())
return GetNextSegment(out sText, out sMarker, out domain);
break;
}
}
}
else if (TypeOfImport == TypeOfImport.Other || TypeOfImport == TypeOfImport.Paratext5)
{
m_scTextSegment = m_scTextEnum.Next();
if (m_scTextSegment != null)
{
sText = m_scTextSegment.Text;
sMarker = m_scTextSegment.Marker;
return true;
}
switch (m_currentDomain)
{
case ImportDomain.Main:
{
m_currentDomain = ImportDomain.BackTrans;
m_scSfmText = new SCScriptureText(m_settings, ImportDomain.BackTrans);
// Now initialize the TextEnum with the range of scripture text we want
m_scTextEnum = m_scSfmText.TextEnum(m_settings.StartRef, m_settings.EndRef);
return GetNextSegment(out sText, out sMarker, out domain);
}
case ImportDomain.BackTrans:
{
m_currentDomain = ImportDomain.Annotations;
m_scSfmText = new SCScriptureText(m_settings, ImportDomain.Annotations);
// Now initialize the TextEnum with the range of scripture text we want
m_scTextEnum = m_scSfmText.TextEnum(m_settings.StartRef, m_settings.EndRef);
return GetNextSegment(out sText, out sMarker, out domain);
}
}
}
else
throw new Exception("GetNextSegment has an invalid import type");
sText = null;
sMarker = null;
return false;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Advance the scripture text object enumerator to the next segment.
/// </summary>
/// <remarks>Virtual to support testing</remarks>
/// <param name="sText">Set to the text of the current segment</param>
/// <param name="sMarker">Set to the marker of the current segment tag</param>
/// <param name="domain">Set to the domain of the stream being processed</param>
/// <returns>True if successful. False if there are no more segments.</returns>
/// ------------------------------------------------------------------------------------
public virtual bool GetNextSegment(out string sText, out string sMarker,
out ImportDomain domain)
{
domain = m_currentDomain;
if (TypeOfImport == TypeOfImport.Paratext6)
{
GetNextParatextSegment(out sText, out sMarker);
if (sMarker != null)
{
return(true);
}
// We didn't get any segment so assume that we hit the end of the data for the book
// ENHANCE: When we support partial book imports, this needs to change.
m_ptCurrBook.BookNum++;
if (m_ptCurrBook.BookNum <= m_settings.EndRef.Book)
{
ResetParatextState();
return(GetNextSegment(out sText, out sMarker, out domain));
}
// We hit the end of our import range so try the next import domain
m_ptCurrBook.BookNum = m_settings.StartRef.Book;
switch (m_currentDomain)
{
case ImportDomain.Main:
{
if (LoadParatextBackTranslationProject())
{
return(GetNextSegment(out sText, out sMarker, out domain));
}
goto case ImportDomain.BackTrans;
}
case ImportDomain.BackTrans:
{
if (LoadParatextNotesProject())
{
return(GetNextSegment(out sText, out sMarker, out domain));
}
break;
}
}
}
else if (TypeOfImport == TypeOfImport.Other || TypeOfImport == TypeOfImport.Paratext5)
{
m_scTextSegment = m_scTextEnum.Next();
if (m_scTextSegment != null)
{
sText = m_scTextSegment.Text;
sMarker = m_scTextSegment.Marker;
return(true);
}
switch (m_currentDomain)
{
case ImportDomain.Main:
{
m_currentDomain = ImportDomain.BackTrans;
m_scSfmText = new SCScriptureText(m_settings, ImportDomain.BackTrans);
// Now initialize the TextEnum with the range of scripture text we want
m_scTextEnum = m_scSfmText.TextEnum(m_settings.StartRef, m_settings.EndRef);
return(GetNextSegment(out sText, out sMarker, out domain));
}
case ImportDomain.BackTrans:
{
m_currentDomain = ImportDomain.Annotations;
m_scSfmText = new SCScriptureText(m_settings, ImportDomain.Annotations);
// Now initialize the TextEnum with the range of scripture text we want
m_scTextEnum = m_scSfmText.TextEnum(m_settings.StartRef, m_settings.EndRef);
return(GetNextSegment(out sText, out sMarker, out domain));
}
}
}
else
{
throw new Exception("GetNextSegment has an invalid import type");
}
sText = null;
sMarker = null;
return(false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Load the P6 Back translation project if it is specified and is to be included
/// </summary>
/// ------------------------------------------------------------------------------------
protected bool LoadParatextBackTranslationProject()
{
if (m_settings.ParatextBTProj == null ||
!(m_settings.ImportBackTranslation || m_settings.ImportAnnotations))
return false;
m_currentDomain = ImportDomain.BackTrans;
LoadParatextProject(m_settings.ParatextBTProj);
return true;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Make sure that the source contains the list of files given
/// </summary>
/// <param name="files"></param>
/// <param name="domain"></param>
/// ------------------------------------------------------------------------------------
private void CheckFileListContents(string[] files, ImportDomain domain)
{
ImportFileSource source = m_importSettings.GetImportFiles(domain);
bool[] found = new bool[files.Length];
foreach (ScrImportFileInfo info in source)
{
bool foundFile = false;
for (int index = 0; index < files.Length; index++)
{
if (info.FileName.ToUpper() == files[index].ToUpper())
{
Assert.IsFalse(found[index], "Found the " + domain + " file twice: " + files[index]);
found[index] = foundFile = true;
break;
}
}
Assert.IsTrue(foundFile, "The file in " + domain + " domain was not found in the list of expected files: " + info.FileName);
}
for (int index = 0; index < found.Length; index++)
Assert.IsTrue(found[index], "File not found in " + domain + " source: " + files[index]);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Add a file to the project, and determine the file encoding and mappings.
/// </summary>
/// <param name="fileName">file name to add</param>
/// <param name="domain">The domain to add the file to</param>
/// <param name="wsId">The writing system identifier for the source (ignored for
/// scripture domain)</param>
/// <param name="noteType">The CmAnnotationDefn for the note type
/// (ignored for back trans and scripture domains)</param>
/// <param name="fileRemovedHandler">Handler for FileRemoved event (can be null if
/// caller doesn't need to know if a file is removed as a result of a overlapping
/// conflict</param>
/// <returns>The IScrImportFileInfo representing the added file</returns>
/// ------------------------------------------------------------------------------------
public IScrImportFileInfo AddFile(string fileName, ImportDomain domain, string wsId,
ICmAnnotationDefn noteType, ScrImportFileEventHandler fileRemovedHandler)
{
lock (SyncRoot)
{
if (ImportTypeEnum == TypeOfImport.Paratext6)
throw new InvalidOperationException("Cannot add files to Paratext 6 import Projects");
// first check to see if the file is already in the project,
// if so - then remove the file.
RemoveFile(fileName, domain, wsId, noteType);
// Make a new file info entry for the added file
IScrImportFileInfo info = m_scrImpFinfoFact.Create(fileName, GetMappingListForDomain(domain),
domain, wsId, noteType,
(ImportTypeEnum == TypeOfImport.Paratext5));
ScrSfFileList fileList = GetFileList(domain, wsId, noteType, true);
if (fileRemovedHandler != null)
fileList.FileRemoved += fileRemovedHandler;
int index;
try
{
index = fileList.Add(info);
}
finally
{
if (fileRemovedHandler != null)
fileList.FileRemoved -= fileRemovedHandler;
}
return (index == -1) ? null : info;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Sets flag to indicate whether this mapping's begin marker is in use in the given
/// import source -- Use this version only for non-Paratext 6.
/// </summary>
/// <param name="importDomain">Import domain of the source</param>
/// <param name="icuLocale">ICU locale of the import source</param>
/// <param name="hvoNoteType">ID of the default note type for the import source</param>
/// <param name="value"><c>true</c> if the marker is in use</param>
/// ------------------------------------------------------------------------------------
public void SetIsInUse(ImportDomain importDomain, string icuLocale, int hvoNoteType,
bool value)
{
m_inUse[ScrImportSet.CreateImportSourceKey(importDomain, icuLocale, hvoNoteType)] = value;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// This is the actual workhorse to Import Scripture
/// </summary>
/// ------------------------------------------------------------------------------------
protected void Import()
{
DateTime beg = DateTime.Now;
// make sure we don't try to listen to all the changes we are making to the
// view during import.
using (new IgnorePropChanged(m_cache, PropChangedHandling.SuppressChangeWatcher))
{
try
{
Initialize();
m_fFoundABook = false;
// Get and process each scripture segment
string sText, sMarker;
ImportDomain domain;
try
{
while (SOWrapper.GetNextSegment(out sText, out sMarker, out domain))
{
// Trace.WriteLine(sMarker + " " + sText);
m_sSegmentText = sText;
m_sMarker = sMarker;
m_importDomain = domain;
ProcessSegment();
}
}
catch (EncodingConverterException e)
{
m_importCallbacks.ErrorMessage(e);
StopImport();
}
// If no book was imported then tell the user that the books they specified didn't
// import properly.
if (!m_fFoundABook)
{
if (FwApp.App != null) // If we're not running the tests
{
string message = string.Format(TeResourceHelper.GetResourceString(
"kstidImportNoBookError"),
(m_settings as ScrImportSet).StartRef.AsString,
(m_settings as ScrImportSet).EndRef.AsString);
m_importCallbacks.ErrorMessage(message);
}
else
{
throw new ArgumentException("Found no book to import");
}
}
FinalizeImport();
}
catch
{
try
{
FinalizeImport();
}
catch {}
throw;
}
finally
{
m_importCallbacks.Position = m_importCallbacks.Maximum;
if (SOWrapper != null)
SOWrapper.Cleanup();
}
}
System.Diagnostics.Debug.WriteLine("import time: " + (DateTime.Now - beg));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Get a MappingSet that is appropriate for the ImportDomain
/// </summary>
/// <param name="domain"></param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
public MappingSet GetMappingSetForDomain(ImportDomain domain)
{
switch (domain)
{
default:
case ImportDomain.Main:
case ImportDomain.BackTrans:
return MappingSet.Main;
case ImportDomain.Annotations:
return MappingSet.Notes;
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Checks the contents of the project combo. We call this after we attempt to assign
/// the projName in the import settings to the current selection in the project combo
/// box.
/// </summary>
/// <param name="projName">Name of the project in the import settings.</param>
/// <param name="projCombo">The project combo.</param>
/// <param name="domain">The import domain.</param>
/// ------------------------------------------------------------------------------------
private void CheckProjectCombo(string projName, FwOverrideComboBox projCombo,
ImportDomain domain)
{
string ptShortName = GetPTShortName(projCombo);
// if the project name was set successfully to the contents of the short name from the combobox.
if (projName != null && projName.Equals(ptShortName))
{
// no problems with the selected item. We're finished.
return;
}
// If the project name is null but the selected project is "none" then the selected
// item is fine. The selected project is "none" when the domain in back translation
// or notes and the selected index in the combobox is 0.
if ((domain == ImportDomain.BackTrans || domain == ImportDomain.Annotations) &&
projCombo.SelectedIndex == 0)
{
return;
}
// However, if the project name is null and the selected item in the combo box
// is something else, then we need to throw an exception so that the user will
// be notified about a problem with the project that they selected.
throw new ParatextLoadException(string.Format(TeResourceHelper.GetResourceString(
"kstidParatextProjectLoadFailure"), ptShortName), null);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Gets a mapping list based on the import domain
/// </summary>
/// <param name="domain">The import domain</param>
/// <returns>The mapping list</returns>
/// ------------------------------------------------------------------------------------
public ScrMappingList GetMappingListForDomain(ImportDomain domain)
{
lock (SyncRoot)
return GetMappingList(GetMappingSetForDomain(domain));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Retrieves the ScrImportSource for the requested domain, WS, and note type
/// </summary>
/// <param name="domain">The source domain</param>
/// <param name="wsId">The writing system identifier for the source (ignored for
/// scripture domain)</param>
/// <param name="noteTypeGuid">The GUID of the CmAnnotationDefn for the note type
/// (ignored for back trans and scripture domains)</param>
/// <param name="createSourceIfNeeded">True to create the source if it does not already
/// exist for a given domain, writing system identifier and note type</param>
/// <returns></returns>
/// ------------------------------------------------------------------------------------
private IScrImportSource GetSource(ImportDomain domain, string wsId,
Guid noteTypeGuid, bool createSourceIfNeeded)
{
switch (domain)
{
case ImportDomain.Main:
return GetSourceForScripture(createSourceIfNeeded);
case ImportDomain.BackTrans:
return GetSourceForBT(wsId, createSourceIfNeeded);
case ImportDomain.Annotations:
{
ICmAnnotationDefn noteType;
try
{
noteType = Cache.ServiceLocator.GetInstance<ICmAnnotationDefnRepository>().GetObject(noteTypeGuid);
}
catch
{
noteType = null;
}
return GetSourceForNotes(wsId, noteType, createSourceIfNeeded);
}
default:
throw new ArgumentException("unexpected domain");
}
}
public bool LoadProjectMappings(string project, ScrMappingList mappingList, ImportDomain domain)
{
// If the new project ID is null, then do not load mappings.
if (project == null)
{
return(false);
}
// Load the tags from the paratext project and create mappings for them.
ScrText scParatextText;
try
{
// REVIEW (EberhardB): I'm not sure if ScrTextCollection.Get() returns a
// reference to a ScrText or a new object (in which case we would have to
// call Dispose() on it)
scParatextText = ScrTextCollection.Get(project);
}
catch (Exception ex)
{
Logger.WriteError(ex);
return(false);
}
mappingList.ResetInUseFlags(domain);
try
{
foreach (ScrTag tag in scParatextText.DefaultStylesheet.Tags)
{
if (tag == null)
{
break;
}
string marker = @"\" + tag.Marker;
string endMarker = string.Empty;
if (!String.IsNullOrEmpty(tag.Endmarker))
{
endMarker = @"\" + tag.Endmarker;
}
// When the nth marker has an end marker, the nth + 1 marker will be
// that end marker. Therefore, we have to skip those "end style" markers.
if (tag.StyleType == ScrStyleType.scEndStyle)
{
continue;
}
// Create a new mapping for this marker.
mappingList.AddDefaultMappingIfNeeded(marker, endMarker, domain, false, false);
}
ScrParser parser = scParatextText.Parser();
foreach (int bookNum in scParatextText.BooksPresentSet.SelectedBookNumbers())
{
foreach (UsfmToken token in parser.GetUsfmTokens(new VerseRef(bookNum, 0, 0), false, true))
{
if (token.Marker == null)
{
continue; // Tokens alternate between text and marker types
}
ImportMappingInfo mapping = mappingList[@"\" + token.Marker];
if (mapping != null)
{
mapping.SetIsInUse(domain, true);
}
// ENHANCE (TE-4408): Consider Detecting markers that occur in the data but are missing
// from the STY file. How can we write a test for this?
//else if (ScrImportFileInfo.IsValidMarker(sMarker))
//{
// mappingList.AddDefaultMappingIfNeeded(sMarker,domain, false, true);
//}
//else
//{
// throw new ScriptureUtilsException(SUE_ErrorCode.InvalidCharacterInMarker, null, 0,
// sMarker + sText, new ScrReference(scParatextTextSegment.FirstReference.BBCCCVVV));
//}
}
}
}
catch (Exception ex)
{
Logger.WriteError(ex);
return(false);
}
return(true);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Add a file to the project, and determine the file encoding and mappings.
/// </summary>
/// <param name="fileName">file name to add</param>
/// <param name="domain">The domain to add the file to</param>
/// <param name="wsId">The icu locale for the source (ignored for scripture domain)
/// </param>
/// <param name="noteType">The CmAnnotationDefn for the note type (ignored for back
/// trans and scripture domains)</param>
/// <returns>The IScrImportFileInfo representing the added file</returns>
/// ------------------------------------------------------------------------------------
public IScrImportFileInfo AddFile(string fileName, ImportDomain domain, string wsId,
ICmAnnotationDefn noteType)
{
return AddFile(fileName, domain, wsId, noteType, null);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Mega constructor with style name
/// </summary>
/// ------------------------------------------------------------------------------------
public ImportMappingInfo(string beginMarker, string endMarker, bool isExcluded,
MappingTargetType mappingTarget, MarkerDomain domain, string styleName,
string icuLocale, ICmAnnotationDefn noteType, bool isInUse, ImportDomain importDomain)
{
m_beginMarker = beginMarker;
m_endMarker = endMarker;
m_isExcluded = isExcluded;
m_mappingTarget = mappingTarget;
m_domain = domain;
m_styleName = styleName;
m_style = null;
m_icuLocale = icuLocale;
m_noteType = noteType;
if (isInUse)
{
m_inUse[ScrImportSet.CreateImportSourceKey(importDomain, icuLocale,
noteType == null ? 0 : noteType.Hvo)] = isInUse;
}
}
