Debian Codegraph @

src/libs/models/reportgenerator/ReportGeneratorOdt.cpp

raw
1 /* This file is part of the KDE project
2 SPDX-FileCopyrightText: 2017 Dag Andersen <[email protected]>
3
4 SPDX-License-Identifier: LGPL-2.0-or-later
5 */
6
7 // clazy:excludeall=qstring-arg
8 #include "planmodels_export.h"
9 #include "ReportGeneratorOdt.h"
10 #include "ReportGeneratorDebug.h"
11
12 #include "kptproject.h"
13 #include "kptschedule.h"
14 #include "kptnodeitemmodel.h"
15 #include "kpttaskstatusmodel.h"
16 #include "kptitemmodelbase.h"
17 #include "kptnodechartmodel.h"
18 #include "kptschedulemodel.h"
19
20 #include <KoXmlReader.h>
21 #include <KoXmlWriter.h>
22 #include <KoOdf.h>
23 #include <KoOdfWriteStore.h>
24 #include <KoOdfReadStore.h>
25 #include <KoStore.h>
26 #include <KoStoreDevice.h>
27 #include <KoXmlNS.h>
28 #include <KoIcon.h>
29
30 #include <KLocalizedString>
31
32 #include <QIODevice>
33 #include <QMimeData>
34 #include <QMimeDatabase>
35 #include <QModelIndex>
36 #include <QByteArray>
37 #include <QDomDocument>
38 #include <QStandardItemModel>
39 #include <QSortFilterProxyModel>
40 #include <QVariantList>
41 #include <QPair>
42
43 namespace KPlato
44 {
45
46 bool addDataToFile(QByteArray &buffer, const QString &destName, KoStore &to)
47 {
48 QBuffer file(&buffer);
49 if (!file.open(QIODevice::ReadOnly)) {
50 dbgRG<<"Failed to open buffer";
51 return false;
52 }
53
54 if (!to.open(destName)) {
55 dbgRG<<"Failed to open file for writing:"<<destName;
56 return false;
57 }
58
59 QByteArray data;
60 data.resize(8 * 1024);
61
62 uint total = 0;
63 for (int block = 0; (block = file.read(data.data(), data.size())) > 0; total += block) {
64 data.resize(block);
65 if (to.write(data) != block) {
66 dbgRG<<"Failed to write block of data";
67 return false;
68 }
69 data.resize(8*1024);
70 }
71
72 to.close();
73 file.close();
74
75 return true;
76 }
77
78
79 //--------------------------------------
80 ReportGeneratorOdt::ReportGeneratorOdt()
81 : ReportGenerator()
82 , m_templateStore(nullptr)
83 {
84 }
85
86
87 ReportGeneratorOdt::~ReportGeneratorOdt()
88 {
89 for (QAbstractItemModel *m : std::as_const(m_datamodels)) {
90 if (!m_basemodels.contains(qobject_cast<ItemModelBase*>(m))) {
91 delete m;
92 }
93 }
94 qDeleteAll(m_basemodels);
95 delete m_templateStore;
96 }
97
98 bool ReportGeneratorOdt::initiateInternal()
99 {
100 if (m_templateStore) {
101 delete m_templateStore;
102 }
103 m_templateStore = KoStore::createStore(m_templateFile, KoStore::Read);
104 if (!m_templateStore) {
105 dbgRG<<"Failed to open store:"<<m_templateFile;
106 m_lastError = i18n("Failed to open template file: %1", m_templateFile);
107 return false;
108 }
109 return true;
110 }
111
112 bool ReportGeneratorOdt::createReport()
113 {
114 if (!m_templateStore) {
115 m_lastError = i18n("Report generator has not been correctly opened");
116 return false;
117 }
118 // TODO get mimetype
119 return createReportOdt();
120 }
121
122 bool ReportGeneratorOdt::createReportOdt()
123 {
124 m_tags.clear();
125 dbgRG<<"url:"<<m_templateStore->urlOfStore();
126
127 KoOdfReadStore reader(m_templateStore);
128 if (!reader.loadAndParse(m_lastError)) {
129 dbgRG<<"Failed to loadAndParse:"<<m_lastError;
130 return false;
131 }
132 // copy manifest file and store a list of file references
133 KoStore *outStore = copyStore(reader, m_reportFile);
134 if (!outStore) {
135 dbgRG<<"Failed to copy template";
136 return false;
137 }
138 dbgRG << '\n' << "---- treat main content.xml ----" << '\n';
139 QBuffer buffer;
140 KoXmlWriter *writer = createOasisXmlWriter(reader, &buffer, QStringLiteral("content.xml"), "office:document-content");
141
142 if (!writer) {
143 dbgRG<<"Failed to create content.xml writer";
144 return false;
145 }
146 KoXmlDocument kodoc = reader.contentDoc();
147 KoXmlElement parent = kodoc.documentElement();
148 writeChildElements(*writer, parent);
149
150 writer->endElement(); // office:document-content
151 writer->endDocument();
152
153 if (!outStore->addDataToFile(buffer.buffer(), QStringLiteral("content.xml"))) {
154 dbgRG<<"Failed to open 'content.xml' for writing";
155 m_lastError = i18n("Failed to write to store: %1", QStringLiteral("content.xml"));
156 delete writer;
157 delete outStore;
158 return false;
159 }
160 buffer.close();
161
162 if (m_manifestfiles.contains(QStringLiteral("styles.xml"))) {
163 dbgRG << '\n' << "---- treat styles.xml (for master-page headers/footers) ----" << '\n';
164 QBuffer buffer2;
165 KoXmlWriter *styles = createOasisXmlWriter(reader, &buffer2, QStringLiteral("styles.xml"), "office:document-styles");
166 if (!styles) {
167 dbgRG<<"Failed to create styles.xml writer";
168 return false;
169 }
170 KoXmlDocument stylesDoc;
171 if (!reader.loadAndParse("styles.xml", stylesDoc, m_lastError)) {
172 debugPlan<<"Failed to read styles.xml"<<m_lastError;
173 delete writer;
174 delete outStore;
175 return false;
176 }
177 writeChildElements(*styles, stylesDoc.documentElement());
178 styles->endElement(); // office:document-styles
179 styles->endDocument();
180 if (!outStore->addDataToFile(buffer2.buffer(), QStringLiteral("styles.xml"))) {
181 dbgRG<<"Failed to open 'styles.xml' for writing";
182 m_lastError = i18n("Failed to write to store: %1", QStringLiteral("styles.xml"));
183 delete writer;
184 delete outStore;
185 }
186 m_manifestfiles.removeAt(m_manifestfiles.indexOf(QStringLiteral("styles.xml")));
187 }
188
189 dbgRG << '\n' << "---- treat the embedded files ----" << '\n';
190 treatEmbededObjects(reader, *outStore);
191 dbgRG << '\n' << "---- copy rest of files ----" << '\n';
192 for (int i = 0; i < m_manifestfiles.count(); ++i) {
193 copyFile(*reader.store(), *outStore, m_manifestfiles.at(i));
194 }
195 if (!outStore->finalize()) {
196 dbgRG<<"Failed to write store:"<<outStore->urlOfStore();
197 m_lastError = i18n("Failed to write report file: %1", outStore->urlOfStore().path());
198 delete writer;
199 delete outStore;
200 return false;
201 }
202 delete writer;
203 delete outStore;
204 dbgRG<<"finished";
205 return true;
206 }
207
208 bool ReportGeneratorOdt::handleTextP(KoXmlWriter &writer, const KoXmlElement &textp)
209 {
210 Q_UNUSED(writer);
211 dbgRG<<"Check:"<<textp.text();
212 // search for user fields
213 KoXmlElement e;
214 forEachElement(e, textp) {
215 QString tag = e.prefix() + QLatin1Char(':') + e.localName();
216 dbgRG<<"Tag:"<<tag;
217 if (tag == QStringLiteral("text:user-field-get")) {
218 QString field = e.attributeNS(KoXmlNS::text, "name");
219 dbgRG<<"Check:"<<field<<m_userfields;
220 if (m_userfields.contains(field) && startsWith(m_keys, field)) {
221 m_sortedfields << field;
222 m_userfields[field]->finish();
223 dbgRG<<"Found:"<<tag<<field;
224 return false;
225 } else {
226 dbgRG<<"Not found:"<<tag<<field<<m_userfields.keys()<<startsWith(m_keys, field);
227 }
228 } else {
229 dbgRG<<" skipping:"<<tag;
230 }
231 }
232 return false;
233 }
234
235 void ReportGeneratorOdt::handleDrawFrame(KoXmlWriter &writer, const KoXmlElement &frame)
236 {
237 Q_UNUSED(writer);
238 dbgRGChart<<m_sortedfields;
239 if (m_sortedfields.isEmpty()) {
240 dbgRGChart<<"No fields";
241 return;
242 }
243 KoXmlElement e = frame.namedItemNS(KoXmlNS::draw, QStringLiteral("object")).toElement();
244 if (e.isNull()) {
245 dbgRGChart<<"No 'object'";
246 return;
247 }
248 QString dir = e.attributeNS(KoXmlNS::xlink, "href");
249 if (dir.isEmpty()) {
250 dbgRGChart<<"No dir";
251 return;
252 }
253 if (m_sortedfields.first().startsWith(QStringLiteral("chart"))) {
254 QString name = m_sortedfields.takeFirst();
255 m_embededcharts[name] = dir;
256 UserField *field = m_userfields[name];
257 QString modelName = field->type + QLatin1Char('.') + field->dataName;
258 field->setModel(dataModel(modelName), m_headerrole[modelName]);
259 dbgRGChart<<"Found chart:"<<field;
260 return;
261 }
262 if (m_sortedfields.first().startsWith(QStringLiteral("gantt"))) {
263 m_embededgantts[m_sortedfields.takeFirst()] = dir;
264 dbgRGChart<<"Found gantt";
265 return;
266 }
267 dbgRGChart<<"No chart or gantt";
268
269 }
270
271 void ReportGeneratorOdt::treatText(KoXmlWriter &writer, const KoXmlText &text)
272 {
273 dbgRG<<" text node:"<<text.data();
274 writer.addTextNode(text.data());
275 }
276
277 void ReportGeneratorOdt::treatTable(KoXmlWriter &writer, const KoXmlElement &tableElement)
278 {
279 const QString name = m_sortedfields.value(0);
280 if (name.startsWith(QStringLiteral("table"))) {
281 dbgRGTable<<" treat table expansion:"<<name;
282 m_sortedfields.takeFirst();
283 m_activefields << name;
284 UserField *field = m_userfields[name];
285 field->seqNr = USERFIELD_NONE;
286 dbgRGTable<<field;
287 writer.startElement("table:table");
288 writeElementAttributes(writer, tableElement);
289 writeChildElements(writer, tableElement);
290 writer.endElement();
291 m_activefields.removeLast();
292 } else {
293 dbgRGTable<<" just a table";
294 writer.startElement("table:table");
295 writeElementAttributes(writer, tableElement);
296 writeChildElements(writer, tableElement);
297 writer.endElement();
298 }
299 }
300
301 bool ReportGeneratorOdt::treatTableHeaderRows(KoXmlWriter &writer, const KoXmlElement &headerRowElement)
302 {
303 Q_UNUSED(writer);
304 Q_UNUSED(headerRowElement);
305
306 if (m_activefields.isEmpty() || m_userfields[m_activefields.last()]->type != QStringLiteral("table")) {
307 return false;
308 }
309 dbgRGTable;
310 UserField *field = m_userfields[m_activefields.last()];
311 field->seqNr = USERFIELD_HEADER; // we are in header row
312 return false;
313 }
314
315 bool ReportGeneratorOdt::treatTableRow(KoXmlWriter &writer, const KoXmlElement &rowElement)
316 {
317 if (m_activefields.isEmpty() || m_userfields[m_activefields.last()]->type != QStringLiteral("table")) {
318 return false;
319 }
320 UserField *field = m_userfields[m_activefields.last()];
321 dbgRGTable<<field->seqNr;
322 if (field->seqNr == USERFIELD_NONE) {
323 // there is no header row, so start with data rows directly
324 field->seqNr = USERFIELD_DATA;
325 }
326 if (field->seqNr == USERFIELD_HEADER) {
327 // header row
328 writer.startElement("table:table-row");
329 writeElementAttributes(writer, rowElement);
330 writeChildElements(writer, rowElement);
331 writer.endElement();
332 field->seqNr = USERFIELD_DATA; // next is first row
333 } else {
334 dbgRGTable<<" add rows:"<<field->rowCount();
335 for (field->begin(); field->next();) {
336 writer.startElement("table:table-row");
337 writeElementAttributes(writer, rowElement);
338 writeChildElements(writer, rowElement);
339 writer.endElement();
340 }
341 field->finish();
342 }
343 return true;
344 }
345
346 ReportGeneratorOdt::UserField *ReportGeneratorOdt::findUserField(const KoXmlElement &decl) const
347 {
348 UserField *field = nullptr;
349 QString name = decl.attributeNS(KoXmlNS::text, "name"); // eg: table1 or table1.Type or project.name or tr.bcws
350
351 field = m_userfields.value(name); // if Variable or Translation
352 if (!field) {
353 QStringList lst = name.split(QLatin1Char('.'));
354 QMap<QString, UserField*>::const_iterator it;
355 for (it = m_userfields.constBegin(); it != m_userfields.constEnd(); ++it) {
356 if (lst.first().startsWith(it.key())) {
357 field = it.value();
358 break;
359 }
360 }
361 }
362 return field;
363 }
364
365 void ReportGeneratorOdt::treatUserFieldGet(KoXmlWriter &writer, const KoXmlElement &e)
366 {
367 dbgRG<<e.text();
368 UserField *field = findUserField(e);
369 if (field) {
370 writer.startElement("text:span");
371 if (field->variant() == UserField::Rows) {
372 QString name = e.attributeNS(KoXmlNS::text, "name"); // eg: table1.type
373 QString value = e.text(); // eg: type or name
374 QString data = field->data(value);
375 writer.addTextNode(data);
376 dbgRGTable<<"rows:"<<name<<value<<'='<<data;
377 } else if (field->variant() == UserField::Header) {
378 QString name = e.attributeNS(KoXmlNS::text, "name"); // eg: table1.type
379 QString value = e.text(); // eg: type or BCWS Cost
380 QString data = field->headerData(value);
381 writer.addTextNode(data);
382 dbgRGTable<<"header row:"<<name<<value<<'='<<data;
383 } else if (field->variant() == UserField::Variable) {
384 QString name = e.attributeNS(KoXmlNS::text, "name"); // eg: project.name
385 dbgRGVariable<<"variable:"<<name<<field->columns.value(0)<<field->data(field->columns.value(0));
386 writer.addTextNode(field->data(field->columns.value(0))); // a variable has only one column
387 } else if (field->variant() == UserField::Translation) {
388 QString name = e.attributeNS(KoXmlNS::text, "name"); // eg: tr.bcws
389 QString data = i18n(field->dataName.toLatin1().constData());
390 if (field->headerNames.contains(field->dataName)) {
391 data = field->data(field->dataName);
392 }
393 dbgRGTr<<"translation:"<<name<<field->dataName<<'='<<data;
394 writer.addTextNode(data);
395 }
396 writer.endElement();
397 } else {
398 // this is not a report field, just copy verbatim
399 writer.startElement("text:user-field-get");
400 writeElementAttributes(writer, e);
401 dbgRG<<"no active user field";
402 writer.endElement();
403 }
404 }
405
406 void ReportGeneratorOdt::handleUserFieldDecls(KoXmlWriter &writer, const KoXmlElement &decls)
407 {
408 // load declarations
409 for (KoXmlNode node = decls.firstChild(); !node.isNull(); node = node.nextSibling()) {
410 if (!node.isElement()) {
411 continue;
412 }
413 KoXmlElement e = node.toElement();
414 QByteArray tag = (QString(e.prefix() + QLatin1Char(':')) + e.localName()).toUtf8();
415 if (tag != "text:user-field-decl") {
416 continue;
417 }
418 QString name = e.attributeNS(KoXmlNS::text, "name");
419 if (name.isEmpty()) {
420 dbgRG<<" User field name is empty";
421 continue;
422 }
423 QString value = e.attributeNS(KoXmlNS::office, "string-value");
424 if (value.isEmpty()) {
425 dbgRG<<" User field value is empty:"<<name;
426 }
427 QStringList tags = name.split(QLatin1Char('.'));
428 dbgRG<<" decl="<<name<<tags;
429 if (tags.first() == QStringLiteral("tr")) {
430 UserField *field = new UserField();
431 field->name = name;
432 m_userfields[field->name] = field;
433
434 field->dataName = value;
435 field->seqNr = USERFIELD_TRANSLATION;
436 field->columns << value;
437 field->setModel(dataModel(QStringLiteral("tr")), m_headerrole[QStringLiteral("tr")]);
438 dbgRGTr<<" added translation"<<field->name<<field->dataName;
439 } else if (m_variables.contains(tags.first())) {
440 Q_ASSERT(tags.count() >= 2);
441 Q_ASSERT(!m_userfields.contains(tags.first()));
442
443 UserField *field = new UserField();
444 field->name = name;
445 m_userfields[field->name] = field;
446
447 field->dataName = tags.first();
448 field->seqNr = USERFIELD_VARIABLE;
449 QStringList vl = value.split(QLatin1Char(';'));
450 if (!vl.isEmpty()) {
451 field->columns << vl.takeFirst();
452 field->properties = vl;
453 }
454 field->setModel(dataModel(field->dataName), m_headerrole[field->dataName]);
455 dbgRGVariable<<" added variable"<<field->name<<field->columns<<field->properties;
456 } else {
457 for (const QString &k : std::as_const(m_keys)) {
458 const QString vname = tags.first();
459 if (!vname.startsWith(k)) {
460 continue;
461 }
462 if (tags.count() == 1) {
463 // this is the main definition (eg: name: "table1", value: "project; values=bcws effort, bcwp effort, acwp effort;")
464 if (!m_userfields.contains(vname)) {
465 m_userfields[vname] = new UserField();
466 }
467 UserField *field = m_userfields[vname];
468 field->name = vname;
469 field->type = k;
470 QStringList vl = trimmed(value.toLower().split(QLatin1Char(';'), Qt::SkipEmptyParts));
471 field->dataName = vl.takeFirst();
472 field->properties += vl;
473 field->setModel(dataModel(field->dataName), m_headerrole[field->dataName]);
474 if (k == QStringLiteral("chart")) {
475 dbgRGChart<<" "<<"added tag:"<<field<<field->properties;
476 } else {
477 dbgRG<<" "<<"added tag:"<<field<<field->properties;
478 }
479 } else {
480 // this is the fields column definitions (eg: name: "table1.type" value: "<not used>")
481 if (!m_userfields.contains(vname)) {
482 m_userfields[vname] = new UserField();
483 UserField *field = m_userfields[vname];
484 field->name = vname;
485 }
486 UserField *field = m_userfields[vname];
487 field->columns << value.trimmed().toLower();
488 Q_ASSERT(field->name == vname);
489 dbgRG<<" "<<"added column:"<<field->name<<field->columns;
490 }
491 }
492 }
493 }
494 writer.startElement("text:user-field-decls");
495 writeElementAttributes(writer, decls);
496 writeChartElements(writer, decls);
497 writer.endElement();
498
499 }
500
501 void ReportGeneratorOdt::writeElementAttributes(KoXmlWriter &writer, const KoXmlElement &element, const QStringList &exclude)
502 {
503 const auto elements = element.attributeFullNames();
504 for (const QPair<QString, QString> &a : elements) {
505 QString prefix = QLatin1String(KoXmlNS::nsURI2NS(a.first));
506 if (prefix.isEmpty()) {
507 dbgRG<<" Skipping unknown namespace:"<<a.first<<a.second;
508 continue;
509 }
510 QString attr = QString(prefix + QLatin1Char(':')) + a.second;
511 if (exclude.contains(attr)) {
512 continue;
513 }
514 m_tags << attr.toUtf8(); // save
515 // dbgRGa.first<<a.second<<"->"<<attr;
516 //dbgRG<<" : "<<m_tags.last().constData()<<'='<<e.attributeNS(a.first, a.second);
517 writer.addAttribute(m_tags.last().constData(), element.attributeNS(a.first, a.second));
518 }
519 }
520
521 void ReportGeneratorOdt::writeChildElements(KoXmlWriter &writer, const KoXmlElement &parent)
522 {
523 //dbgRG<<parent.prefix()<<QLatin1Char(':')<<parent.localName();
524 for (KoXmlNode node = parent.firstChild(); !node.isNull(); node = node.nextSibling()) {
525 if (node.isText()) {
526 writer.addTextNode(node.toText().data());
527 continue;
528 }
529 // dbgRG<<node.prefix()<<node.localName()<<node.nodeType();
530 KoXmlElement e = node.toElement();
531 if (e.isNull()) {
532 continue;
533 }
534 // dbgRG<<" "<<e.prefix()<<e.localName() << e.attributeFullNames();
535 QByteArray tag = (QString(e.prefix() + QLatin1Char(':')) + e.localName()).toUtf8();
536 m_tags << tag; // make sure tags survives until we are finished
537 if (tag == "text:user-field-decls") {
538 handleUserFieldDecls(writer, e);
539 continue;
540 }
541 if (tag == "text:user-field-decl") {
542 dbgRG<<"Should we get here?"<<tag;
543 continue; // treated by handleUserFieldDecls()
544 }
545 if (tag == "table:table") {
546 treatTable(writer, e);
547 continue;
548 }
549 if (tag == "table:table-header-rows") {
550 if (treatTableHeaderRows(writer, e)) {
551 continue; // header rows treats its own children
552 }
553 }
554 if (tag == "table:table-row") {
555 if (treatTableRow(writer, e)) {
556 continue;
557 }
558 }
559 if (tag == "text:user-field-get") {
560 treatUserFieldGet(writer, e);
561 continue;
562 }
563 if (tag == "text:p") {
564 // check for/handle keywords
565 if (handleTextP(writer, e)) {
566 dbgRG<<"Skip:"<<tag;
567 continue;
568 }
569 }
570 if (tag == "draw:frame") {
571 handleDrawFrame(writer, e);
572 }
573 writer.startElement(tag.constData());
574 writeElementAttributes(writer, e);
575 writeChildElements(writer, e);
576 writer.endElement();
577 }
578 }
579
580 bool ReportGeneratorOdt::copyFile(KoStore &from, KoStore &to, const char *file)
581 {
582 return copyFile(from, to, QString::fromLatin1(file));
583 }
584 bool ReportGeneratorOdt::copyFile(KoStore &from, KoStore &to, const QString &file)
585 {
586 QByteArray data;
587 bool ok = from.extractFile(file, data);
588 if (!ok) {
589 dbgRG<<"Failed to extract:"<<file;
590 m_lastError = i18n("Failed to extract file: %1", file);
591 }
592 if (ok) {
593 ok = addDataToFile(data, file, to);
594 if (!ok) {
595 dbgRG<<"Failed to add file:"<<file;
596 m_lastError = i18n("Failed to add file to store: %1", file);
597 }
598 }
599 if (ok) {
600 dbgRG<<"Added:"<<file;
601 }
602 return ok;
603 }
604
605 KoStore *ReportGeneratorOdt::copyStore(KoOdfReadStore &reader, const QString &outfile)
606 {
607 if (!reader.store()->hasFile("META-INF/manifest.xml")) {
608 dbgRG<<"No manifest file";
609 return nullptr;
610 }
611 KoXmlDocument manifest;
612 if (!reader.loadAndParse("META-INF/manifest.xml", manifest, m_lastError)) {
613 dbgRG<<"Failed to read manifest:"<<m_lastError;
614 return nullptr;
615 }
616 QUrl url = QUrl::fromUserInput(outfile);
617 if (!url.isLocalFile()) {
618 // FIXME: KoStore only handles local files
619 dbgRG<<"KoStore only handles local files:"<<url;
620 m_lastError = i18n("Report generator can only generate local files");
621 return nullptr;
622 }
623 const auto path = url.toLocalFile();
624 KoStore *out = KoStore::createStore(path, KoStore::Write);
625 if (!out) {
626 dbgRG<<"Failed to create store";
627 m_lastError = i18n("Failed to open report file: %1", url.path());
628 return nullptr;
629 }
630 // This should go first, see OpenDocument v1.2 part 3: Packages
631 if (reader.store()->hasFile("mimetype")) {
632 if (!copyFile(*reader.store(), *out, "mimetype")) {
633 if (!m_lastError.isEmpty()) {
634 m_lastError.prepend(QLatin1String("\n\n"));
635 }
636 m_lastError.prepend(i18n("Failed to load mimetype file"));
637 delete out;
638 return nullptr;
639 }
640 }
641 if (!copyFile(*reader.store(), *out, "META-INF/manifest.xml")) {
642 if (!m_lastError.isEmpty()) {
643 m_lastError.prepend(QLatin1String("\n\n"));
644 }
645 m_lastError.prepend(i18n("Failed to write manifest file"));
646 delete out;
647 return nullptr;
648 }
649
650 KoXmlElement e;
651 forEachElement(e, manifest.documentElement()) {
652 dbgRG<<e.tagName()<<e.attributeNames();
653 QString file;
654 if (e.hasAttribute("full-path")) {
655 file = e.attribute("full-path");
656 if (file.isEmpty() || file == QStringLiteral("content.xml") || file.endsWith(QStringLiteral("/"))) {
657 file.clear();
658 continue;
659 }
660 }
661 if (!file.isEmpty()) {
662 m_manifestfiles << file;
663 }
664 }
665 return out;
666 }
667
668 KoXmlWriter *ReportGeneratorOdt::createOasisXmlWriter(KoOdfReadStore &reader, QBuffer *buffer, const QString fileName, const char *rootElementName)
669 {
670 if (!reader.store()) {
671 m_lastError = i18n("No store backend");
672 dbgRG<<"No store";
673 return nullptr;
674 }
675 dbgRGTmp<<fileName<<rootElementName<<"has file:"<<reader.store()->hasFile(fileName);
676 if (reader.store()->isOpen()) {
677 reader.store()->close();
678 }
679 if (!reader.store()->open(fileName)) {
680 dbgRG << "Entry " << fileName << " not found!";
681 m_lastError = xi18nc("@info", "Failed to open file <filename>%1</filename> from store.", fileName);
682 return nullptr;
683 }
684 if (!reader.store()->device()->isOpen()) {
685 reader.store()->device()->open(QIODevice::ReadOnly);
686 }
687 KoXmlWriter *writer = nullptr;
688 QXmlStreamReader xml(reader.store()->device());
689 xml.setNamespaceProcessing(true);
690 while (!xml.atEnd()) {
691 xml.readNext();
692 if (xml.tokenType() == QXmlStreamReader::StartElement && !xml.namespaceDeclarations().isEmpty()) {
693 writer = new KoXmlWriter(buffer);
694 writer->startDocument(rootElementName);
695 writer->startElement(rootElementName);
696 writer->addAttribute("xmlns:calligra", KoXmlNS::calligra);
697
698 // Note: windows needs this type of iteration
699 QXmlStreamNamespaceDeclarations dcl = xml.namespaceDeclarations();
700 for (int ns = 0; ns < dcl.count(); ++ns) {
701 dbgRGTmp<<"add namespace:"<<(QStringLiteral("xmlns:") + dcl[ns].prefix())<<dcl[ns].namespaceUri();
702 writer->addAttribute((QStringLiteral("xmlns:") + dcl[ns].prefix()).toLatin1().constData(), dcl[ns].namespaceUri().toUtf8());
703 }
704 QXmlStreamAttributes attr = xml.attributes();
705 for (int a = 0; a < attr.count(); ++a) {
706 dbgRGTmp<<"add attribute:"<<attr[a].qualifiedName().toString()<<attr[a].value().toString();
707 writer->addAttribute(attr[a].qualifiedName().toLatin1().constData(), attr[a].value().toUtf8());
708 }
709 }
710 }
711 reader.store()->close();
712 if (!writer) {
713 dbgRG<<"Failed to find a start element with namespace declarations in"<<fileName;
714 m_lastError = xi18nc("@info", "Missing namespace declarations:<nl/><filename>%1</filename>", fileName);
715 }
716 return writer;
717 }
718
719 void ReportGeneratorOdt::treatEmbededObjects(KoOdfReadStore &reader, KoStore &outStore)
720 {
721 dbgRGChart;
722 {QMap<QString, QString>::const_iterator it;
723 for (it = m_embededcharts.constBegin(); it != m_embededcharts.constEnd(); ++it) {
724 treatChart(reader, outStore, it.key(), it.value());
725 }}
726 {QMap<QString, QString>::const_iterator it;
727 for (it = m_embededgantts.constBegin(); it != m_embededgantts.constEnd(); ++it) {
728 treatGantt(reader, outStore, it.key(), it.value());
729 }}
730 }
731
732 void ReportGeneratorOdt::treatChart(KoOdfReadStore &reader, KoStore &outStore, const QString &name, const QString &dir)
733 {
734 dbgRGChart<<name<<dir;
735 if (!m_userfields.contains(name)) {
736 dbgRGChart<<"No user field with name:"<<name;
737 return;
738 }
739 QString file = dir + QStringLiteral("/content.xml");
740 file = file.remove(QStringLiteral("./"));
741 dbgRGChart<<file<<m_manifestfiles;
742 QString err;
743 KoXmlDocument doc;
744 if (!reader.loadAndParse(file, doc, err)) {
745 dbgRGChart<<err;
746 return;
747 }
748 m_activefields << name;
749 UserField *field = m_userfields[name];
750 if (field->dataName == QStringLiteral("project")) {
751 ChartItemModel *m = findChartItemModel(field->model);
752 if (m) {
753 m->setNodes(QList<Node*>() << m_project);
754 }
755 if (field->properties.isEmpty()) {
756 // default: take all
757 for (const QString &c : std::as_const(field->headerNames)) {
758 field->columns << c;
759 }
760 } else {
761 QStringList values;
762 for (const QString &p : std::as_const(field->properties)) {
763 if (p.startsWith(QStringLiteral("values"))) {
764 QStringList vl = p.split(QStringLiteral("="));
765 Q_ASSERT(vl.count() > 1);
766 Q_ASSERT(vl.at(0) == QStringLiteral("values"));
767 const auto strings = vl.at(1).split(QLatin1Char(','));
768 for (const auto &v : strings) {
769 values << v.toLower().trimmed();
770 }
771 }
772 }
773 field->columns = values;
774 }
775 dbgRGChart<<field;
776
777 }
778 QBuffer buffer;
779 KoXmlWriter *writer = createOasisXmlWriter(reader, &buffer, file, "office:document-content");
780
781 writeChartElements(*writer, doc.documentElement());
782
783 writer->endElement(); // office:document-content
784 writer->endDocument();
785
786 dbgRGChart<<writer->toString();
787 if (!outStore.addDataToFile(buffer.buffer(), file)) {
788 dbgRGChart<<"Failed to open"<<file<<"for writing";
789 m_lastError = i18n("Failed to write to store: %1", file);
790 }
791
792 m_manifestfiles.removeAt(m_manifestfiles.indexOf(file));
793 dbgRGChart<<m_manifestfiles;
794 }
795
796 void ReportGeneratorOdt::treatGantt(KoOdfReadStore &reader, KoStore &outStore, const QString &name, const QString &file)
797 {
798 Q_UNUSED(reader);
799 Q_UNUSED(outStore);
800 Q_UNUSED(name);
801 Q_UNUSED(file);
802 dbgRGChart;
803 }
804
805 void ReportGeneratorOdt::writeChartElements(KoXmlWriter &writer, const KoXmlElement &parent)
806 {
807 dbgRGChart<<"writeChartElements: parent="<<parent.prefix()<<','<<parent.localName();
808 for (KoXmlNode node = parent.firstChild(); !node.isNull(); node = node.nextSibling()) {
809 if (node.isText()) {
810 writer.addTextNode(node.toText().data());
811 continue;
812 }
813 KoXmlElement e = node.toElement();
814 if (e.isNull()) {
815 continue;
816 }
817 //dbgRGChart<<" "<<e.namespaceURI()<<e.prefix()<<e.localName() << e.attributeFullNames();
818 if (QLatin1String(KoXmlNS::nsURI2NS(e.namespaceURI())).isEmpty()) {
819 continue; // skip unknown namespace
820 }
821 QByteArray tag = (e.prefix() + QLatin1Char(':') + e.localName()).toUtf8();
822 m_tags << tag; // make sure tags survives until we are finished
823 //dbgRGChart<<" handle element:"<<tag;
824
825 if (tag == "chart:plot-area") {
826 UserField *field = m_userfields[m_activefields.last()];
827 field->hasLabels = e.attributeNS(KoXmlNS::chart, "data-source-has-labels");
828
829 writer.startElement(tag.constData());
830 writeElementAttributes(writer, e);
831 writeChartElements(writer, e);
832 writer.endElement();
833 } else if (tag == "chart:categories") {
834 // assume this is x-axis
835 UserField *field = m_userfields[m_activefields.last()];
836 int columns = field->columnCount();
837 if (columns > 0) {
838 writer.startElement(tag.constData());
839 writeElementAttributes(writer, e, QStringList() << QStringLiteral("table:cell-range-address"));
840
841 int startRow = 1;
842 if (field->hasLabels == QStringLiteral("both") || field->hasLabels == QStringLiteral("primary-x")) {
843 ++startRow;
844 }
845 QString end = QStringLiteral("local-table.$A$%1:$A$%2").arg(startRow).arg(startRow+field->rowCount()-1);
846 writer.addAttribute("table:cell-range-address", end);
847
848 writeChartElements(writer, e);
849 writer.endElement();
850 }
851 } else if (tag == "chart:series") {
852 UserField *field = m_userfields[m_activefields.last()];
853 int columns = field->columnCount();
854 if (columns > 0 && field->serieNr < columns) {
855 int startRow = 1;
856 if (field->hasLabels == QStringLiteral("both") || field->hasLabels == QStringLiteral("primary-x")) {
857 ++startRow;
858 }
859 char startColumn = 'A';
860 if (field->hasLabels == QStringLiteral("both") || field->hasLabels == QStringLiteral("primary-y")) {
861 ++startColumn;
862 }
863 writer.startElement(tag.constData());
864 writeElementAttributes(writer, e, QStringList() << QStringLiteral("chart:values-cell-range-address")<<QStringLiteral("chart:label-cell-address"));
865
866 QChar c(startColumn + field->serieNr);
867
868 QString lab = QStringLiteral("local-table.$%1$1").arg(c);
869 writer.addAttribute("chart:values-cell-address", lab);
870
871 QString end = QStringLiteral("local-table.$%1$%2:$%1$%3").arg(c).arg(startRow).arg(startRow+field->rowCount()-1);
872 writer.addAttribute("chart:values-cell-range-address", end);
873
874 writer.startElement("chart:data-point");
875 writer.addAttribute("chart:repeated", field->rowCount());
876 writer.endElement();
877
878 writer.endElement();
879
880 ++field->serieNr;
881 }
882 } else if (tag == "chart:data-point") {
883 // do nothing handled under chart:series
884 } else if (tag == "table:table-header-columns") {
885 writer.startElement(tag.constData());
886 writer.startElement("table:table-column"); // just an empty tag
887 writer.endElement();
888 writer.endElement();
889 } else if (tag == "table:table-columns") {
890 writer.startElement(tag.constData());
891 writeChartElements(writer, e);
892 writer.endElement();
893 } else if (tag == "table:table-column") {
894 int columns = m_userfields[m_activefields.last()]->columnCount();
895 writer.startElement(tag.constData());
896 writer.addAttribute("table:number-columns-repeated", columns);
897 writer.endElement();
898 } else if (tag == "table:table-header-rows") {
899 writer.startElement(tag.constData());
900 writer.startElement("table:table-row");
901 // first column not used, just an empty cell
902 writer.startElement("table:table-cell");
903 writer.startElement("text:p");
904 writer.endElement();
905 writer.endElement();
906 // write legends
907 UserField *field = m_userfields[m_activefields.last()];
908 for (const QString &name : std::as_const(field->columns)) {
909 QString value = field->headerData(name);
910 writer.startElement("table:table-cell");
911 writer.addAttribute("office:value-type", "string");
912 writer.startElement("text:p");
913 writer.addTextNode(value);
914 writer.endElement();
915 writer.endElement();
916 }
917 writer.endElement();
918 writer.endElement();
919 } else if (tag == "table:table-rows") {
920 writer.startElement(tag.constData());
921 UserField *field = m_userfields[m_activefields.last()];
922 int columns = field->columnCount();
923 if (columns > 0) {
924 int rows = field->model.rowCount();
925 for (int r = 0; r < rows; ++r) {
926 writer.startElement("table:table-row");
927 // first x-axis labels
928 QDate date = QDate(field->model.headerData(r, Qt::Vertical, Qt::EditRole).toDate());
929 // NOTE: 1899-12-30 is the reference date, but could it depend on style?
930 int day = QDate(1899, 12, 30).daysTo(date);
931 writer.startElement("table:table-cell");
932 writer.addAttribute("office:value", day);
933 writer.addAttribute("office:value-type", "float");
934 writer.startElement("text:p");
935 writer.addTextNode(QString::number(day));
936 writer.endElement();
937 writer.endElement();
938 // then the data
939 for (const QString &name : std::as_const(field->columns)) {
940 QVariant value = field->model.index(r, field->column(name)).data();
941 writer.startElement("table:table-cell");
942 writer.addAttribute("office:value-type", "float");
943 writer.addAttribute("office:value", value.toDouble());
944 writer.startElement("text:p");
945 writer.addTextNode(QString::number(value.toDouble()));
946 writer.endElement();
947 writer.endElement();
948 }
949 writer.endElement();
950 }
951 }
952 writer.endElement();
953 } else if (tag == "chart:legend") {
954 writer.startElement(tag.constData());
955 if (!e.hasAttributeNS(KoXmlNS::chart, "legend-align") && e.hasAttributeNS(KoXmlNS::chart, "legend-position")) {
956 // lowriter does not specify this attribute
957 // If legend-position is start, end, top or bottom
958 // we need to have legend-align == center so that words
959 // repositions the legend correctly
960 QStringList lst = QStringList() << QStringLiteral("start") << QStringLiteral("end") << QStringLiteral("top") << QStringLiteral("bottom");
961 if (lst.contains(e.attributeNS(KoXmlNS::chart, "legend-position"))) {
962 writer.addAttribute("chart:legend-align", "center");
963 dbgRGChart<<"adding legend-align";
964 }
965 }
966 writeElementAttributes(writer, e);
967 writeChartElements(writer, e);
968 writer.endElement();
969 } else {
970 writer.startElement(tag.constData());
971 writeElementAttributes(writer, e);
972 writeChartElements(writer, e);
973 writer.endElement();
974 }
975 }
976 }
977
978 void ReportGeneratorOdt::listChildNodes(const QDomNode &parent)
979 {
980 QDomNodeList lst = parent.childNodes();
981 for (int i = 0; i < lst.count(); ++i) {
982 if (lst.at(i).isElement()) {
983 QDomElement e = lst.at(i).toElement();
984 dbgRG<<"Element:"<<e.tagName()<<"value="<<e.text();
985 QDomNamedNodeMap map = e.attributes();
986 for (int j = 0; j < map.count(); ++j) {
987 QDomAttr attr = map.item(j).toAttr();
988 dbgRG<<" "<<attr.name()<<attr.value();
989 }
990 }
991 listChildNodes(lst.at(i));
992 }
993 }
994
995 QAbstractItemModel *ReportGeneratorOdt::dataModel(const QString &name) const
996 {
997 dbgRG<<name<<m_datamodels;
998 return m_datamodels.value(name);
999 }
1000
1001 void ReportGeneratorOdt::UserField::setModel(QAbstractItemModel *model, int role)
1002 {
1003 headerNames.clear();
1004 this->model.setSourceModel(model);
1005 for (int c = 0; c < this->model.columnCount(); ++c) {
1006 headerNames << this->model.headerData(c, Qt::Horizontal, role).toString().toLower();
1007 }
1008 }
1009
1010 int ReportGeneratorOdt::UserField::column(const QString &columnName) const
1011 {
1012 QStringList l = columnName.split(QLatin1Char('.'));
1013 int c = l.isEmpty() ? -1 : headerNames.indexOf(l.last().toLower());
1014 dbgRGTable<<" column:"<<columnName<<'='<<c;
1015 return c;
1016 }
1017
1018 void ReportGeneratorOdt::UserField::begin()
1019 {
1020 currentIndex = QModelIndex();
1021 }
1022
1023 bool ReportGeneratorOdt::UserField::next()
1024 {
1025 if (model.hasChildren(currentIndex)) {
1026 currentIndex = model.index(0, column(columns.value(0)), currentIndex);
1027 } else {
1028 do {
1029 QModelIndex idx = currentIndex.sibling(currentIndex.row()+1, column(columns.value(0)));
1030 if (idx.isValid()) {
1031 currentIndex = idx;
1032 break;
1033 }
1034 currentIndex = model.parent(currentIndex);
1035 } while (currentIndex.isValid());
1036 }
1037 return currentIndex.isValid();
1038 }
1039
1040 void ReportGeneratorOdt::UserField::finish()
1041 {
1042 currentIndex = QModelIndex();
1043 if (seqNr > USERFIELD_NONE) {
1044 seqNr = USERFIELD_NONE;
1045 }
1046 }
1047
1048 QString ReportGeneratorOdt::UserField::data(const QString &column) const
1049 {
1050 QModelIndex idx;
1051 if (currentIndex.isValid()) {
1052 idx = model.index(currentIndex.row(), this->column(column), currentIndex.parent());
1053 } else {
1054 idx = model.index(0, this->column(column));
1055 }
1056 QString s = QStringLiteral("No data");
1057 if (idx.isValid()) {
1058 s = model.data(idx).toString();
1059 }
1060 dbgRG<<column<<'='<<s;
1061 return s;
1062 }
1063
1064 QString ReportGeneratorOdt::UserField::headerData(const QString &columnName) const
1065 {
1066 return model.headerData(column(columnName), Qt::Horizontal).toString();
1067 }
1068
1069 int ReportGeneratorOdt::UserField::rowCount()
1070 {
1071 int rows = 0;
1072 for (begin(); next(); ++rows) {}
1073 return rows;
1074 }
1075
1076 int ReportGeneratorOdt::UserField::variant() const
1077 {
1078 int t = Rows;
1079 switch (seqNr) {
1080 case USERFIELD_TRANSLATION: t = Translation; break;
1081 case USERFIELD_VARIABLE: t = Variable; break;
1082 case USERFIELD_NONE: t = None; break;
1083 case USERFIELD_HEADER: t = Header; break;
1084 default: break;
1085 }
1086 return t;
1087 }
1088
1089 QDebug operator<<(QDebug dbg, ReportGeneratorOdt::UserField *f)
1090 {
1091 if (f) {
1092 return operator<<(dbg, *f);
1093 }
1094 dbg << "UserField(0x0)";
1095 return dbg;
1096 }
1097 QDebug operator<<(QDebug dbg, ReportGeneratorOdt::UserField &f)
1098 {
1099 dbg.nospace() << "UserField[";
1100 switch (f.variant()) {
1101 case ReportGeneratorOdt::UserField::Header: dbg << QStringLiteral("H: ") + f.name + QLatin1Char('.') + f.dataName; break;
1102 case ReportGeneratorOdt::UserField::Rows: dbg << QStringLiteral("R: ") + f.name + QLatin1Char('.') + f.dataName << "seqNr: " << f.seqNr; break;
1103 case ReportGeneratorOdt::UserField::Variable: dbg << QStringLiteral("V: ") + f.name; break;
1104 case ReportGeneratorOdt::UserField::Translation: dbg << QStringLiteral("T: ") + f.name; break;
1105 default: dbg << QStringLiteral("U: ") + f.name; break;
1106 }
1107 // if (!f.columns.isEmpty()) {
1108 // dbg << '\n' <<"Columns: " << f.columns;
1109 // }
1110 // if (!f.headerNames.isEmpty()) {
1111 // dbg << '\n' << "Headers: " << f.headerNames;
1112 // }
1113 // if (!f.columns.isEmpty() || !f.headerNames.isEmpty()) {
1114 // dbg << '\n';
1115 // }
1116 dbg << ']';
1117 return dbg.space();
1118 }
1119
1120 } //namespace KPlato