private static IExportNastaveni GetExportSettings(string documentType,
DocxToTeiConverterSettings settings,
string xsltTransformationsDirectoryPath,
string xsltTemplatesDirectoryPath,
AdresarovaStruktura ads,
IPrepis prepis)
{
string xsltTransformationFilePath = Path.Combine(xsltTransformationsDirectoryPath, documentType + XmlExtension);
IExportNastaveni exportSettings = null;
switch (documentType)
{
case "Edition":
case "ProfessionalLiterature":
exportSettings = GetEdicniModulNastaveni(settings, xsltTransformationFilePath, xsltTemplatesDirectoryPath, ads, prepis);
break;
case "Dictionary":
exportSettings = GetDictionarySettings(settings, xsltTransformationFilePath, xsltTemplatesDirectoryPath, ads, prepis);
break;
case "Grammar":
exportSettings = GetGrammarSettings(settings, xsltTransformationFilePath, xsltTemplatesDirectoryPath, ads, prepis);
break;
}
return(exportSettings);
}
public override void GenerateConversionMetadataFile(
ExportBase export,
IExportNastaveni settings,
string documentType,
string finalOutputFileFullPath,
string finalOutputFileName,
string finalOutputMetadataFileName)
{
var fiFinalOutputFilename = new FileInfo(finalOutputFileFullPath);
var step = 0;
var outputFileWithoutExtension = fiFinalOutputFilename.Name.Substring(0, fiFinalOutputFilename.Name.LastIndexOf(".", StringComparison.Ordinal));
var fileTransformationSource = finalOutputFileFullPath;
var parameters = new NameValueCollection
{
{ "accessories", finalOutputFileName }
};
foreach (var transformationFile in XsltTransformerFactory.GetTransformationFromTransformationsFile(settings.SouborTransformaci, "jgslov-xmd-step"))
{
var fileTransformationTarget = GetTempFile(settings.DocasnaSlozka, outputFileWithoutExtension, step++);
export.ApplyTransformations(fileTransformationSource, fileTransformationTarget, XsltTransformerFactory.GetXsltTransformers(
settings.SouborTransformaci,
transformationFile,
settings.SlozkaXslt, true), settings.DocasnaSlozka, parameters);
fileTransformationSource = fileTransformationTarget;
}
File.Copy(fileTransformationSource, finalOutputMetadataFileName);
}
/// <summary>
/// Vytvoří biblických míst odkazy na biblická místa.
/// </summary>
/// <param name="strVstup">Název výstupního souboru</param>
/// <param name="emnNastaveni">Nastavení pro ediční modul</param>
/// <param name="strNazev">Název pramene (bez přípon dokumentu)</param>
/// <param name="iPoradi">Pořadí dokumentu ve zpracování</param>
/// <returns>Vrací název vytvořeného souboru</returns>
private static string OdkazyNaBiblickyText(string strVstup, IExportNastaveni emnNastaveni, string strNazev, int iPoradi)
{
string strVystup = Path.Combine(emnNastaveni.DocasnaSlozka, String.Format(cstrNazevVystupuFormat, strNazev, iPoradi));
using (XmlReader xr = XmlReader.Create(strVstup))
{
using (XmlWriter xw = XmlWriter.Create(strVystup))
{
while (xr.Read())
{
if (xr.NodeType == XmlNodeType.Element)
{
string sNazev = xr.Name;
if (sNazev == "anchor")
{
string sType;
string sSubtype;
string sN;
NactiAtributy(xr, out sType, out sSubtype, out sN);
if (sType == "bible" && sSubtype == "book")
{
StrukturaBible sb = new StrukturaBible();
sb.Kniha = sN;
xr.Read();
NactiAtributy(xr, out sType, out sSubtype, out sN);
if (sType == "bible" && sSubtype == "chapter")
sb.Kapitola = sN;
else
{
ZapsatOdkazNaBiblickeMisto(sb, xw);
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
break;
}
xr.Read();
NactiAtributy(xr, out sType, out sSubtype, out sN);
if (sType == "bible" && sSubtype == "verse")
sb.Vers = sN;
else
{
ZapsatOdkazNaBiblickeMisto(sb, xw);
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
break;
}
ZapsatOdkazNaBiblickeMisto(sb, xw);
}
else
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
}
else
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
}
else
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
}
}
return strVystup;
}
}
/// <summary>
/// Zpracuje odkazy na biblická místa v nebiblických textech; označí je jako text přidaný editorem
/// </summary>
/// <param name="emnNastaveni">Nastavení exportu pro ediční modul</param>
/// <param name="strNazev">Název pramene (bez přípon dokumentu)</param>
/// <param name="glsTransformacniSablony">Seznam transformačních šalbon (používá se pro identifikaci pořadí generovaného souboru)</param>
/// <param name="glsVystupy"></param>
/// <param name="strVystup"></param>
/// <returns></returns>
internal static string ZpracovatOdkazyNaBiblickaMista(IExportNastaveni emnNastaveni, string strNazev, List<string> glsTransformacniSablony, List<string> glsVystupy, string strVystup)
{
string strVstup;
int i = glsTransformacniSablony.Count;
strVystup = OdkazyNaBiblickyText(strVystup, emnNastaveni, strNazev, i);
glsVystupy.Add(strVystup);
strVstup = strVystup;
return strVstup;
}
private ExportBase GetExportModule(string documentType, IExportNastaveni exportSettings)
{
switch (documentType)
{
case "Edition":
case "ProfessionalLiterature":
return(new EdicniModul(exportSettings));
case "Dictionary":
return(new SlovnikovyModul(exportSettings));
case "Grammar":
return(new ModulMluvnic(exportSettings));
}
return(null);
}
internal static string ZpracovatBiblickyText(IExportNastaveni emnNastaveni, string strNazev, List<string> glsTransformacniSablony, List<string> glsVystupy, string strVstup)
{
string strVystup;
int i = 0;
if (glsTransformacniSablony != null)
i = glsTransformacniSablony.Count;
strVstup = RozdelitBibliNaKnihyAKapitoly(strVstup, emnNastaveni, strNazev, i);
glsVystupy.Add(strVstup);
strVystup = strVstup;
strVstup = RozdelitBibliNaVerse(strVystup, emnNastaveni, strNazev, ++i);
glsVystupy.Add(strVstup);
strVystup = strVstup;
return strVystup;
}
protected ExportBase(IExportNastaveni nastaveni)
{
Nastaveni = nastaveni;
}
public ConversionResult Convert(DocxToTeiConverterSettings settings)
{
ConverterSettings = settings;
CheckIfDirectoryPathsExists(ConverterSettings);
_result = new ConversionResult();
string documentType = null;
//get metadata only for first (by alphabet) uploaded file
var inputFileName = ConverterSettings.InputFilesPath.Select(filePath => new FileInfo(filePath)).Select(fileInfo => fileInfo.Name).First();
ResolveDefaultSettingsValues(ConverterSettings);
var prepis = GetPrepisy(ConverterSettings, inputFileName);
if (prepis == null)
{
//dokument v evidenci neexistuje, nabídnout zanesení dokumentu do evidence
// mělo by stačit přiřazení typu dokumentu
_result.Errors.Add(new DocumentNotInEvidenceException(String.Format("Dokument s uvedeným jménem souboru '{0}' neexistuje v evidenci.", inputFileName)));
return(_result);
}
if (prepis.FazeZpracovani < FazeZpracovani.Exportovat)
{
_result.Errors.Add(new DocumentNotInRequredStateException("Dokument s uvedeným jménem souboru není připraven pro export."));
return(_result);
}
documentType = GetDocumentType(prepis.TypPrepisu);
_documentId = prepis.GUID;
if (documentType == null)
{
//dokument má v evidenci přiřazen typ dokumentu, který není podporován
_result.Errors.Add(new NotSupportedFileFormatException("Dokument má v evidenci přiřazen typ dokumentu, který není podporován."));
return(_result);
}
string tempDirectoryPath = ConverterSettings.TempDirectoryPath;
//vytvoří se adresářová struktura, pokud neexistuje, pro ukládání výsledných a dočasných souborů
AdresarovaStruktura ads = new AdresarovaStruktura(tempDirectoryPath, documentType);
ads.VytvorStrukturu();
string docxToXmlFilePath = Path.Combine(GetDataDirectoryPath(), "AllStylesConvert.2xml");
string xsltTemplatesPath = GetXsltTemplatesPath();
string xsltTransformationsPath = GetXsltTransformationsPath();
string fileNameWithoutExtension = prepis.Soubor.NazevBezPripony;
string xmlOutpuFileName = fileNameWithoutExtension + XmlExtension;
string finalOutputDirectory = ads.DejVystup; // Path.Combine(ads.DejVystup, fileNameWithoutExtension);
string finalOutputFileName = Path.Combine(finalOutputDirectory, xmlOutpuFileName);
//Zatím pouze konverze z DOCX do základního XML
IList <string> xmlOutputFiles = new List <string>();
try
{
var filePart = 0;
foreach (var inputFilePath in ConverterSettings.InputFilesPath)
{
xmlOutputFiles.Add(GetDocxToXmlOutput(ads, prepis.Soubor.NazevBezPripony, filePart, ConverterSettings.InputFilesPath.Length > 1));
ConvertDocxToXml(inputFilePath, docxToXmlFilePath, xmlOutputFiles.Last());
filePart++;
}
}
catch (Exception exception)
{
_result.Errors.Add(exception);
return(_result);
}
if (!Directory.Exists(finalOutputDirectory))
{
Directory.CreateDirectory(finalOutputDirectory);
}
IExportNastaveni exportSettings = GetExportSettings(documentType, ConverterSettings, xsltTransformationsPath, xsltTemplatesPath, ads, prepis);
ExportBase export = GetExportModule(documentType, exportSettings);
if (export == null || exportSettings == null)
{
//Objekt pro export se nepodažřilo vytvořit, není podporován.
return(_result);
}
try
{
export.Exportuj(exportSettings.Prepis, xmlOutputFiles, ConverterSettings.UploadedFilesPath);
_result.IsConverted = true;
}
catch (Exception exception)
{
_result.Errors.Add(exception);
return(_result);
}
if (!settings.Debug)
{
foreach (var xmlOutputFile in xmlOutputFiles.Where(File.Exists))
{
File.Delete(xmlOutputFile);
}
}
var versions = settings.GetVersionList(_documentId);
_currentVersionInfoSkeleton = versions.Last();
WriteListChange(finalOutputFileName, versions, _currentVersionInfoSkeleton);
var xmlFinalOutputPath = Path.Combine(settings.OutputDirectoryPath, xmlOutpuFileName);
File.Copy(finalOutputFileName, xmlFinalOutputPath, true);
_result.MetadataFilePath = settings.OutputMetadataFilePath;
//GetConversionMetadataFileFullPath(settings.OutputFilePath);
if (export.UsePersonalizedXmdGenerator)
{
export.GenerateConversionMetadataFile(documentType, xmlFinalOutputPath, xmlOutpuFileName, settings.OutputMetadataFilePath);
}
else
{
SplittingResult splittingResult = null;
if (settings.SplitDocumentByPageBreaks)
{
splittingResult = SplitDocumentByPageBreaks(xmlFinalOutputPath, fileNameWithoutExtension);
if (!splittingResult.IsSplitted)
{
_result.IsConverted = false;
_result.Errors.Add(new DocumentSplittingException("Vyskytla se chyba při rozdělení souboru podle hranice stran."));
}
}
TableOfContentResult tocResult = null;
ContentInfoBuilder tocBuilder = new ContentInfoBuilder();
tocResult = tocBuilder.MakeTableOfContent(xmlFinalOutputPath, "body");
GenerateConversionMetadataFile(splittingResult, tocResult, documentType, xmlFinalOutputPath, xmlOutpuFileName, settings.OutputMetadataFilePath);
}
if (!settings.Debug)
{
try
{
Directory.Delete(settings.TempDirectoryPath, true);
}
catch (IOException exception)
{
Directory.Delete(settings.TempDirectoryPath, true);
}
}
return(_result);
}
public EdicniModulUpravy(IExportNastaveni emnNastaveni)
: base(emnNastaveni)
{
}
/// <summary>
/// Upraví jeden přepis, transformuje ho do podoby pro ediční modul
/// </summary>
/// <param name="prp">Přepis (informace o něm)</param>
/// <param name="emnNastaveni">Nastavení exportu pro ediční modul</param>
/// <param name="glsTransformacniSablony">Seznam transformačních šablon XSLT, které se při úpravách použijí</param>
public static void Uprav(IPrepis prp, IExportNastaveni emnNastaveni, List <string> glsTransformacniSablony)
{
//
string sCesta = Path.Combine(emnNastaveni.VstupniSlozka, prp.Soubor.Nazev);
sCesta = sCesta.Replace(".docx", ".xml").Replace(".doc", ".xml");
FileInfo fi = new FileInfo(sCesta);
if (!fi.Exists)
{
throw new FileNotFoundException("Zadaný soubor '" + sCesta + "' neexistuje.");
}
if (emnNastaveni.DocasnaSlozka == null)
{
emnNastaveni.DocasnaSlozka = Path.GetTempPath();
}
//Zpracovat hlavičku a front
string strNazev = fi.Name.Substring(0, fi.Name.Length - fi.Extension.Length);
Console.WriteLine("Zpracovávám soubor '{0}'", strNazev);
XmlWriter xw;
string sFront = Path.Combine(emnNastaveni.SlozkaXslt, "Vytvorit_front_TEI.xsl");
string sFrontVystup = Path.Combine(emnNastaveni.DocasnaSlozka, strNazev + "_front.xml");
List <string> glsVystupy = new List <string>(glsTransformacniSablony.Count + 2);
/*
* UpravaSouboruXml uprava = new UpravaSouboruXml(UpravHlavicku);
*
*
* Dictionary<string, string> gdcParam = new Dictionary<string, string>();
* gdcParam.Add("soubor", prp.NazevSouboru);
* TransformacniKrok tkh = new TransformacniKrok(Path.Combine(emnNastaveni.SlozkaXslt, "EM_Vytvorit_hlavicku_TEI.xsl"), emnNastaveni.SouborMetadat, gdcParam);
*/
string sHlavicka = Path.Combine(emnNastaveni.SlozkaXslt, "EM_Vytvorit_hlavicku_TEI.xsl");
string sHlavickaVystup = Path.Combine(emnNastaveni.DocasnaSlozka, strNazev + "_hlavicka.xml");
XslCompiledTransform xctHlavick = new XslCompiledTransform();
xctHlavick.Load(sHlavicka);
XsltArgumentList xal = new XsltArgumentList();
xal.AddParam("soubor", "", prp.NazevSouboru);
xw = XmlWriter.Create(sHlavickaVystup);
xctHlavick.Transform(emnNastaveni.SouborMetadat, xal, xw);
xw.Close();
glsVystupy.Add(sHlavickaVystup);
XslCompiledTransform xctFront = new XslCompiledTransform();
xctFront.Load(sFront);
xw = XmlWriter.Create(sFrontVystup);
xctFront.Transform(emnNastaveni.SouborMetadat, xal, xw);
xw.Close();
glsVystupy.Add(sFrontVystup);
string strVstup = sCesta;
string strVystup = null;
for (int i = 0; i < glsTransformacniSablony.Count; i++)
{
strVystup = Path.Combine(emnNastaveni.DocasnaSlozka, String.Format(cstrNazevVystupuFormat, strNazev, i));
glsVystupy.Add(strVystup);
XslCompiledTransform xslt = new XslCompiledTransform();
Console.WriteLine("{0} = {1}", String.Format(cstrNazevVystupuFormat, strNazev, i),
glsTransformacniSablony[i]);
xslt.Load(glsTransformacniSablony[i]);
xslt.Transform(strVstup, strVystup);
strVstup = strVystup;
}
if (prp.LiterarniZanr == "biblický text")
{
strVstup = ZpracovatBiblickyText(emnNastaveni, strNazev, glsTransformacniSablony, glsVystupy, strVystup);
}
else
{
strVstup = ZpracovatOdkazyNaBiblickaMista(emnNastaveni, strNazev, glsTransformacniSablony, glsVystupy,
strVystup);
}
string sSlouceni = Path.Combine(emnNastaveni.SlozkaXslt, "EM_Spojit_s_hlavickou_a_front.xsl"); //EBV
strVystup = Path.Combine(emnNastaveni.DocasnaSlozka,
String.Format(cstrNazevVystupuFormat, strNazev, glsVystupy.Count));
XsltSettings xsltSettings = new XsltSettings(true, false);
XslCompiledTransform xctSlouceni = new XslCompiledTransform();
xctSlouceni.Load(sSlouceni, xsltSettings, null);
xal = new XsltArgumentList();
xal.AddParam("hlavicka", "", sHlavickaVystup);
xal.AddParam("zacatek", "", sFrontVystup);
xw = XmlWriter.Create(strVystup);
xctSlouceni.Transform(strVstup, xal, xw);
xw.Close();
strVstup = strVystup;
glsVystupy.Add(strVystup);
/*
* strVystup = Path.Combine(emnNastaveni.DocasnaSlozka, String.Format("{0}_{1:00}.xml", strNazev, glsVystupy.Count));
* PresunoutMezeryVneTagu(strVstup, strVystup);
* glsVystupy.Add(strVystup);
* strVstup = strVystup;
*/
string sEdicniKomentar = Path.Combine(emnNastaveni.SlozkaXslt, "EM_Presunout_edicni_komentar.xsl");
strVystup = Path.Combine(emnNastaveni.DocasnaSlozka,
String.Format(cstrNazevVystupuFormat, strNazev, glsVystupy.Count));
XmlUrlResolver xrl = new XmlUrlResolver();
XslCompiledTransform xctEdicniKomentare = new XslCompiledTransform();
xctEdicniKomentare.Load(sEdicniKomentar, xsltSettings, xrl);
xw = XmlWriter.Create(strVystup);
xctEdicniKomentare.Transform(strVstup, xal, xw);
xw.Close();
glsVystupy.Add(strVystup);
strVstup = strVystup;
strVystup = Path.Combine(emnNastaveni.VystupniSlozka, strNazev + ".xml");
PresunoutMezeryVneTagu(strVstup, strVystup);
//File.Copy(strVystup, Path.Combine(emnNastaveni.VystupniSlozka, strNazev + ".xml"),true);
}
public ModulMluvnic(IExportNastaveni nastaveni) : base(nastaveni)
{
UsePersonalizedXmdGenerator = true;
}
public SlovnikovyModul(IExportNastaveni emnNastaveni) : base(emnNastaveni)
{
}
private static string RozdelitBibliNaVerse(string strVstup, IExportNastaveni emnNastaveni, string strNazev, int iPoradi)
{
string strVystup = Path.Combine(emnNastaveni.DocasnaSlozka, String.Format(cstrNazevVystupuFormat, strNazev, iPoradi));
using (XmlReader xr = XmlReader.Create(strVstup))
{
using (XmlWriter xw = XmlWriter.Create(strVystup))
{
StrukturaBible sbBible = new StrukturaBible();
bool blnPrvniVers = true;
while (xr.Read())
{
if (xr.NodeType == XmlNodeType.Element)
{
string sNazev = xr.Name;
string sTyp;
string sPodtyp;
string sN;
switch (sNazev)
{
case "div":
sTyp = xr.GetAttribute("type");
sPodtyp = xr.GetAttribute("subtype");
sN = xr.GetAttribute("n");
if (sTyp == "bible" && sPodtyp == "book")
sbBible.Kniha = sN;
if (sTyp == "bible" && sPodtyp == "chapter")
{
if (sbBible.Kapitola != sN)
{
blnPrvniVers = true;
sbBible.Kapitola = sN;
}
}
goto default;
case "anchor":
sTyp = xr.GetAttribute("type");
sPodtyp = xr.GetAttribute("subtype");
sN = xr.GetAttribute("n");
if (sTyp == "delimiter")
{
if (sPodtyp == "chapterStart")
{
sbBible.Kapitola = sN;
blnPrvniVers = true;
}
else if (sPodtyp == "chapterEnd")
{
xw.WriteEndElement(); //předchozí <seg>
}
goto default;
}
if (sTyp == "bible")
{
if (sPodtyp == "chapter")
{
sbBible.Kapitola = sN;
goto default;
}
if (sPodtyp == "verse")
{
if (!blnPrvniVers)
{
xw.WriteEndElement();
}
blnPrvniVers = false;
sbBible.Vers = sN;
xw.WriteStartElement("seg");
xw.WriteAttributeString("type", sTyp);
xw.WriteAttributeString("subtype", sPodtyp);
xw.WriteAttributeString("n", sN);
xw.WriteAttributeString("xml", "id", "http://www.w3.org/XML/1998/namespace", sbBible.IdentifikatorXml());
}
}
else
{
goto default;
}
break;
//na začátku odstavce je vždy "první" verš, nesmí se ukončit předchozí značka
case "p":
blnPrvniVers = true;
goto default;
default:
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
break;
} // switch (sNazev) {
} // if (xr.NodeType == XmlNodeType.Element) {
else if (xr.NodeType == XmlNodeType.EndElement)
{
if (xr.Name == "p" && sbBible.Kapitola != null)
{
xw.WriteEndElement(); //</seg>
}
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
}
else
{
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
}
} //while (xr.Read())
} //using (XmlWriter xw = XmlWriter.Create(strVystup))
} //using (XmlReader xr = XmlReader.Create(strVstup))
return strVystup;
}
private static string RozdelitBibliNaKnihyAKapitoly(string strVstup, IExportNastaveni emnNastaveni,
string strNazev, int iPoradi)
{
string strVystup = Path.Combine(emnNastaveni.DocasnaSlozka, String.Format(cstrNazevVystupuFormat, strNazev, iPoradi));
using (XmlReader xr = XmlReader.Create(strVstup))
{
using (XmlWriter xw = XmlWriter.Create(strVystup))
{
StrukturaBible sbBible = new StrukturaBible();
string sKonecKapitoly = null;
while (xr.Read())
{
if (xr.NodeType == XmlNodeType.Element)
{
string sNazev = xr.Name;
switch (sNazev)
{
/*
case "anchor":
string sTyp = xr.GetAttribute("type");
string sPodtyp = xr.GetAttribute("subtype");
string sId = xr.GetAttribute("xml:id");
break;
*/
case "div":
XmlDocument xdc = Pomucky.Xml.Objekty.ReadNodeAsXmlDocument(xr);
XmlNodeList xnlp = xdc.SelectNodes("//p");
Dictionary<XmlNode, KrajniStrukturyBible> dcOdstavecMisto = new Dictionary<XmlNode, KrajniStrukturyBible>();
if (xnlp != null)
{
if (xnlp.Count > 1)
{
List<XmlNodeList> xnlpb = new List<XmlNodeList>();
List<XmlNodeList> xnlpc = new List<XmlNodeList>();
List<XmlNodeList> xnlpv = new List<XmlNodeList>();
foreach (XmlNode node in xnlp)
{
XmlNodeList nlpb = node.SelectNodes(".//anchor[@type='bible' and @subtype = 'book']");
xnlpb.Add(nlpb);
XmlNodeList nlpc = node.SelectNodes(".//anchor[@type='bible' and @subtype = 'chapter']");
xnlpc.Add(nlpc);
XmlNodeList nlpv = node.SelectNodes(".//anchor[@type='bible' and @subtype = 'verse']");
xnlpv.Add(nlpv);
StrukturaBible sb1 = new StrukturaBible();
if (nlpb != null)
sb1.Kniha = StrukturaBible.ZiskejUdajZAtributu(nlpb[0].Attributes["xml:id"].Value);
if (nlpc != null)
sb1.Kapitola = StrukturaBible.ZiskejUdajZAtributu(nlpc[0].Attributes["xml:id"].Value);
if (nlpv != null)
sb1.Vers = StrukturaBible.ZiskejUdajZAtributu(nlpv[0].Attributes["xml:id"].Value);
StrukturaBible sbp = new StrukturaBible();
if (nlpb != null)
sbp.Kniha = StrukturaBible.ZiskejUdajZAtributu(nlpb[nlpb.Count - 1].Attributes["xml:id"].Value);
if (nlpc != null)
sbp.Kapitola = StrukturaBible.ZiskejUdajZAtributu(nlpc[nlpc.Count - 1].Attributes["xml:id"].Value);
if (nlpv != null)
sbp.Vers = StrukturaBible.ZiskejUdajZAtributu(nlpv[nlpc.Count - 1].Attributes["xml:id"].Value);
KrajniStrukturyBible ksb = new KrajniStrukturyBible(sb1, sbp);
dcOdstavecMisto.Add(node, ksb);
}
bool bCoOdstavecToKapitola = false;
foreach (KeyValuePair<XmlNode, KrajniStrukturyBible> kvp in dcOdstavecMisto)
{
if (kvp.Value.Zacatek.Kapitola == kvp.Value.Konec.Kapitola)
{
bCoOdstavecToKapitola = true;
}
else
{
bCoOdstavecToKapitola = false;
break;
}
}
if (bCoOdstavecToKapitola)
{
foreach (KeyValuePair<XmlNode, KrajniStrukturyBible> kvp in dcOdstavecMisto)
{
xw.WriteStartElement("div");
xw.WriteAttributeString("type", "bible");
xw.WriteAttributeString("subtype", "chapter");
xw.WriteAttributeString("n", kvp.Value.Zacatek.Kapitola);
xw.WriteAttributeString("xml", "id", "http://www.w3.org/XML/1998/namespace",
new StrukturaBible(kvp.Value.Zacatek.Kniha, kvp.Value.Zacatek.Kapitola).IdentifikatorXml(VypisStruktury.Kapitola)
);
kvp.Key.WriteTo(xw);
xw.WriteEndElement(); //div
}
break;
}
}
}
XmlNodeList xnlb = xdc.SelectNodes("//anchor[@type='bible' and @subtype = 'book']");
XmlNodeList xnlc = xdc.SelectNodes("//anchor[@type='bible' and @subtype = 'chapter']");
XmlNodeList xnlv = xdc.SelectNodes("//anchor[@type='bible' and @subtype = 'verse']");
if (xnlb != null && xnlb.Count > 0)
{
string sKniha = null;
XmlNode xnb = xnlb[0];
if (xnb.Attributes != null)
sKniha = xnb.Attributes.GetNamedItem("xml:id").Value;
sKniha = StrukturaBible.ZiskejUdajZAtributu(sKniha);
if (sbBible.Kniha != sKniha)
{
if (sbBible.Kniha != null)
{
xw.WriteEndElement(); //div
}
sbBible.Kniha = sKniha;
xw.WriteStartElement("div");
//xw.WriteAttributeString("type", "book");
xw.WriteAttributeString("type", "bible");
xw.WriteAttributeString("subtype", "book");
xw.WriteAttributeString("n", sKniha);
xw.WriteAttributeString("xml", "id", "http://www.w3.org/XML/1998/namespace", sbBible.IdentifikatorXml(VypisStruktury.Kniha));
/*
XmlAttribute xa = xdc.CreateAttribute("type");
xa.Value = "book";
XmlAttribute xan = xdc.CreateAttribute("n");
xan.Value = sKniha;
XmlAttribute xaid = xdc.CreateAttribute("xml", "id", "http://www.w3.org/XML/1998/namespace");
xaid.Value = StrukturaBible.IdentifikatorXml(sKniha);
xdc.DocumentElement.Attributes.Append(xa);
xdc.DocumentElement.Attributes.Append(xan);
xdc.DocumentElement.Attributes.Append(xaid);
*/
}
foreach (XmlNode node in xnlb)
{
if (node.ParentNode != null)
node.ParentNode.RemoveChild(node);
}
}
if (xnlv != null)
if (xnlc != null && xnlv.Count > 0)
{
string sKonec = null;
XmlNode xnck = xnlc[xnlc.Count - 1];
if (xnck.Attributes != null)
sKonec = xnck.Attributes.GetNamedItem("xml:id").Value;
sKonec = StrukturaBible.ZiskejUdajZAtributu(sKonec);
XmlNode xncz = xnlc[0];
if (xncz.Attributes != null)
{
string sZacatekKapitoly = xncz.Attributes.GetNamedItem("xml:id").Value;
sZacatekKapitoly = StrukturaBible.ZiskejUdajZAtributu(sZacatekKapitoly);
sbBible.Kapitola = sZacatekKapitoly;
if (sZacatekKapitoly == sKonec)
{
if (sKonec != sKonecKapitoly)
{
/*
XmlAttribute xat = xdc.CreateAttribute("type");
xat.Value = "chapter";
xdc.DocumentElement.Attributes.Append(xat);
*/
XmlAttribute xat = xdc.CreateAttribute("type");
xat.Value = "bible";
XmlNode xde = xdc.DocumentElement;
if (xde != null)
{
if (xde.Attributes != null)
xde.Attributes.Append(xat);
xat = xdc.CreateAttribute("subtype");
xat.Value = "chapter";
if (xde.Attributes != null)
xde.Attributes.Append(xat);
XmlAttribute xan = xdc.CreateAttribute("n");
xan.Value = sZacatekKapitoly;
if (xde.Attributes != null)
xde.Attributes.Append(xan);
XmlAttribute xaid = xdc.CreateAttribute("xml", "id", "http://www.w3.org/XML/1998/namespace");
xaid.Value = sbBible.IdentifikatorXml(VypisStruktury.Kapitola);
if (xde.Attributes != null)
xde.Attributes.Append(xaid);
}
}
foreach (XmlNode node in xnlc)
{
if (node.ParentNode != null)
node.ParentNode.RemoveChild(node);
}
}
else
{
XmlElement xe = VytvoritAnchorChapterStart(xdc, sbBible, sZacatekKapitoly);
if (xdc.DocumentElement != null)
xdc.DocumentElement.InsertBefore(xe, xdc.DocumentElement.FirstChild);
bool bBylKonec = false;
foreach (XmlNode node in xnlc)
{
if (node.Attributes != null)
{
string sk = StrukturaBible.ZiskejUdajZAtributu(node.Attributes.GetNamedItem("xml:id").Value);
if (!bBylKonec && sk == sKonec)
{
bBylKonec = true;
XmlElement xche = VytvoritAnchorChapterEnd(xdc, sbBible, sZacatekKapitoly);
XmlElement xchs = VytvoritAnchorChapterStart(xdc, sbBible, sKonec);
if (node.ParentNode != null)
{
node.ParentNode.InsertBefore(xche, node);
node.ParentNode.InsertBefore(xchs, node);
}
}
}
if (node.ParentNode != null)
node.ParentNode.RemoveChild(node);
}
}
}
sKonecKapitoly = sKonec;
}
xdc.WriteTo(xw);
/*
if (xnlc != null && xnlv.Count > 0) {
xw.WriteEndElement(); //<div type='chapter'>
}
*/
break;
default:
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
break;
}
}
else if (xr.NodeType == XmlNodeType.EndElement)
{
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
}
else
{
Pomucky.Xml.Transformace.SerializeNode(xr, xw);
}
}
}
}
return strVystup;
}
