BibliographyBackbone: Difference between revisions

From Illustrations in German Translations of Mark Twain's Works

← Older edit
VisualWikitext
No edit summary
No edit summary
 
(16 intermediate revisions by the same user not shown)
Line 1: Line 1:
{{Seitenkopf|Bibliography Generator}}
{{Seitenkopf|Bibliography Generator}}
<html>
<html>
<button id="testBtn" style="
<div style="max-width: 1000px;">
 
<button id="generateBtn" style="
   background-color: #008CBA;
   background-color: #008CBA;
   color: white;
   color: white;
Line 10: Line 13:
   cursor: pointer;
   cursor: pointer;
   margin-bottom: 1rem;
   margin-bottom: 1rem;
">Test Fetch</button>
">Generate Bibliography HTML</button>


<textarea id="bibOutput" style="
<textarea id="bibOutput" style="
   width: 100%;
   width: 100%;
   height: 600px;
   height: 400px;
   font-family: 'Courier New', monospace;
   font-family: 'Courier New', monospace;
   font-size: 0.85rem;
   font-size: 0.85rem;
Line 26: Line 29:


<script>
<script>
/**
(function() {
* Minimales Test-Script für BibliographyData
  function escapeHtml(text) {
*/
    if (!text) return '';
    const map = {
      '&': '&amp;',
      '<': '&lt;',
      '>': '&gt;',
      '"': '&quot;',
      "'": '&#039;'
    };
    return text.replace(/[&<>"']/g, m => map[m]);
  }
 
  function getOrUnknown(value) {
    if (!value || (typeof value === 'string' && !value.trim())) {
      return 'unknown';
    }
    return value;
  }
 
  function formatAuthors(authors) {
    if (!authors || authors.length === 0) {
      return 'unknown';
    }
   
    if (authors.length === 1) {
      const a = authors[0];
      const family = a.family || 'unknown';
      const given = a.given || '';
      return given ? `${family}, ${given}` : family;
    }
   
    if (authors.length === 2) {
      const a1 = authors[0];
      const a2 = authors[1];
      const name1 = (a1.family || 'unknown') + (a1.given ? ', ' + a1.given : '');
      const name2 = (a2.family || 'unknown') + (a2.given ? ', ' + a2.given : '');
      return `${name1}, and ${name2}`;
    }
 
    const a = authors[0];
    const name = (a.family || 'unknown') + (a.given ? ', ' + a.given : '');
    return `${name}, et al.`;
  }
 
  function formatMLA9(entry) {
    let citation = '';
 
    const authors = formatAuthors(entry.authors);
    citation += authors + '. ';


(function() {
    const title = getOrUnknown(entry.title);
  'use strict';
    if (entry.type === 'bookSection' || entry.type === 'book') {
      citation += `<i>${escapeHtml(title)}</i>. `;
    } else {
      citation += `"${escapeHtml(title)}." `;
    }
 
    const container = entry.container;
    if (container && container.trim()) {
      citation += `<i>${escapeHtml(container)}</i>. `;
    }
 
    const year = getOrUnknown(entry.year);
    citation += `${year}. `;
 
    if (entry.url && entry.url.trim()) {
      citation += `<a href="${escapeHtml(entry.url)}" target="_blank">${escapeHtml(entry.url)}</a>.`;
    } else {
      citation = citation.trim();
      if (!citation.endsWith('.')) {
        citation += '.';
      }
    }


  async function testFetch() {
     return citation;
     const output = document.getElementById('bibOutput');
  }
    output.value = 'Versuche zu laden...\n';


    // Test 1: Normales Fetch
  function generateTagsAttribute(tags) {
    try {
    if (!tags || tags.length === 0) {
      output.value += '\n=== Test 1: Normales Fetch ===\n';
       return ' data-tags="untagged"';
      const response = await fetch('/BibliographyData');
      output.value += `Status: ${response.status}\n`;
      const text = await response.text();
      output.value += `Länge: ${text.length} Zeichen\n`;
      output.value += `Erste 500 Zeichen:\n${text.substring(0, 500)}\n`;
    } catch (err) {
       output.value += `Fehler: ${err.message}\n`;
     }
     }
    const normalized = tags
      .map(tag => tag.toLowerCase().replace(/\s+/g, '_'))
      .join(' ');
    return ` data-tags="${normalized}"`;
  }


    // Test 2: Mit ?action=raw
  function generateTagSpans(tags) {
    try {
    if (!tags || tags.length === 0) {
      output.value += '\n=== Test 2: Mit ?action=raw ===\n';
       return '<span class="tag" data-tag="untagged">untagged</span>';
      const response = await fetch('/BibliographyData?action=raw');
      output.value += `Status: ${response.status}\n`;
      const text = await response.text();
      output.value += `Länge: ${text.length} Zeichen\n`;
      output.value += `Erste 500 Zeichen:\n${text.substring(0, 500)}\n`;
    } catch (err) {
       output.value += `Fehler: ${err.message}\n`;
     }
     }
    return tags
      .map(tag => {
        const normalized = tag.toLowerCase().replace(/\s+/g, '_');
        return `<span class="tag" data-tag="${normalized}">${escapeHtml(tag)}</span>`;
      })
      .join('\n    ');
  }
  function generateBibEntry(entry, index) {
    const mlaFormatted = formatMLA9(entry);
    const tagsAttr = generateTagsAttribute(entry.tags);
    const tagSpans = generateTagSpans(entry.tags);
    const abstract = entry.abstract && entry.abstract.trim() ? escapeHtml(entry.abstract) : '';
    return `<!-- ${index} -->
<div class="bib-entry"${tagsAttr}>
  <h3>${mlaFormatted}</h3>
  <div class="bib-tags">
    ${tagSpans}
  </div>
  <p class="short-abstract">${abstract || '(No abstract available)'}</p>
  <button class="expand-btn">Show Abstract</button>
  <div class="abstract hidden">
    <p>${abstract || 'No abstract available.'}</p>
  </div>
</div>`;
  }
  async function generateBibliography() {
    const output = document.getElementById('bibOutput');
    output.value = 'Lade Daten...';


    // Test 3: Versuche JSON zu parsen
     try {
     try {
      output.value += '\n=== Test 3: JSON Parse ===\n';
       const response = await fetch('/BibliographyData?action=raw');
       const response = await fetch('/BibliographyData?action=raw');
       const text = await response.text();
       if (!response.ok) throw new Error(`HTTP ${response.status}`);
        
        
      // Versuche direkt zu parsen
       const entries = await response.json();
       const json = JSON.parse(text);
 
       output.value += `✓ JSON erfolgreich geparst!\n`;
       const filtered = entries.filter(entry => {
      output.value += `Anzahl Einträge: ${json.length}\n`;
        if (entry.tags && entry.tags.includes('Not relevant for Mark Twain')) {
      if (json.length > 0) {
          return false;
         output.value += `Erster Eintrag: ${JSON.stringify(json[0], null, 2)}\n`;
        }
       }
         if (!entry.title || entry.title.trim() === 'Untitled') {
    } catch (err) {
          return false;
       output.value += `Fehler beim JSON Parse: ${err.message}\n`;
        }
     
        return true;
      // Versuche die nowiki zu entfernen
       });
      try {
 
        output.value += '\n--- Versuche <nowiki> zu entfernen ---\n';
      const allTags = new Set();
         const response = await fetch('/BibliographyData?action=raw');
       filtered.forEach(entry => {
         let text = await response.text();
        if (entry.tags && Array.isArray(entry.tags)) {
          
          entry.tags.forEach(tag => allTags.add(tag));
        // Entferne <nowiki> Tags
         }
        text = text.replace(/<\/?nowiki>/g, '');
      });
        output.value += `Nach Entfernung von nowiki, erste 500 Zeichen:\n${text.substring(0, 500)}\n`;
 
          
      const tagSpans = Array.from(allTags)
         const json = JSON.parse(text);
         .sort()
         output.value += `✓ JSON erfolgreich geparst!\n`;
         .map(tag => {
        output.value += `Anzahl Einträge: ${json.length}\n`;
          const normalized = tag.toLowerCase().replace(/\s+/g, '_');
      } catch (err2) {
          return `<span class="tag" data-tag="${normalized}">${escapeHtml(tag)}</span>`;
        output.value += `Immer noch Fehler: ${err2.message}\n`;
         })
      }
         .join('\n  ');
    }
 
  }
      const entryHTML = filtered
        .map((entry, i) => generateBibEntry(entry, i + 1))
         .join('\n\n');
 
      const html = `<div class="bib-tags">
  ${tagSpans}
</div>
 
<div id="listView" class="bibliography">
${entryHTML}
</div>
 
<div id="networkView" class="network hidden"></div>`;


  function init() {
      output.value = html;
    const btn = document.getElementById('testBtn');
     } catch (error) {
     if (btn) {
       output.value = 'ERROR: ' + error.message;
       btn.addEventListener('click', testFetch);
      console.log('Test-Script bereit');
    } else {
      console.error('Button nicht gefunden');
     }
     }
   }
   }


   if (document.readyState === 'loading') {
   const btn = document.getElementById('generateBtn');
     document.addEventListener('DOMContentLoaded', init);
  if (btn) {
  } else {
     btn.addEventListener('click', generateBibliography);
    init();
   }
   }
})();
})();
</script>
</script>
</div>
</html>
</html>

Latest revision as of 00:51, 12 May 2026

Bibliography Generator

Retrieved from "https://illus.twainframe.org/index.php?title=BibliographyBackbone&oldid=2890"