s10k/XmlTools/xmlpatch.cpp

#include "xmlpatch.h"

XmlPatch::XmlPatch(QString patchFilesWildcard, QString forceTargetFilesWildcard, bool noBackups, bool noVerbose)
{
    this->patchFilesToProcess=UtilXmlTools::getAllPatchFilesByWildcard(patchFilesWildcard);
    this->forceTargetFilesWildcard=forceTargetFilesWildcard;
    this->backupsEnabled=!noBackups;
    this->verboseEnabled=!noVerbose;

    if(forceTargetFilesWildcard!=""){
        std::cout << "User forced patch in the target file(s): " << forceTargetFilesWildcard.toUtf8().constData() << std::endl;
    }

    if(this->patchFilesToProcess.isEmpty()){
        UtilXmlTools::displayErrorMessage("Loading patch files","No .patch or .oni-patch files were found for the wildcard: "+patchFilesWildcard);
    }

}

void XmlPatch::readAndProcessPatchFile(){

    // Process all PatchFiles
    for(int i=0; i<this->patchFilesToProcess.size(); i++){

        QFile inputFile(this->patchFilesToProcess[i]);

        if (inputFile.open(QIODevice::ReadOnly))
        {

            QTextStream fileStream(&inputFile);

            checkPatchVersion(this->patchFilesToProcess[i], fileStream);
            checkAndProcessValidCommands(fileStream);

            inputFile.close();
        }
        else{
            UtilXmlTools::displayErrorMessage("Read patch file", "Error opening patch file: '" + this->patchFilesToProcess[i] + "'.\n" + inputFile.errorString());
        }

    }

    UtilXmlTools::displaySuccessMessage(this->patchFilesToProcess.size(),"Patch File(s)");

}

void XmlPatch::insertNodesOperation(const QString &xmlString, XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){

    QVector<QString> filesToProcess;
    QList<pugi::xml_node> nodesToInsertion;
    pugi::xml_document newNode;
    pugi::xml_parse_result result;

    try{

        filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);

        if(filesToProcess.isEmpty()){
            UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","No XML files were found for the wildcard: "+filesWildcard);
        }

        result=newNode.load(xmlString.toUtf8().constData()); // load xml to insert

        if(result.status!=pugi::status_ok){
            UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES", "The xml node to insert is invalid.\n" + QString(result.description()));
        }

        // Process all XmlFiles
        for(int i=0; i<filesToProcess.size(); i++){

            UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@ADD_INSIDE_NODES");

            // Check how the element will be fetched via element name or xpath expression
            if(xPathExpression.isEmpty()){
                UtilXmlTools::getAllNamedElements(this->rootNode,nodesToInsertion,filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToInsertion);
            }

            if(nodesToInsertion.isEmpty() || nodesToInsertion[0].type()==pugi::node_null){

                QString errMessage;

                if(xPathExpression.isEmpty()){
                    errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
                    if(filters.getParentElementName()!=""){
                        errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
                    }
                    if(filters.getAttributeName()!=""){
                        errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
                    }
                }
                else{
                    errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
                }

                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES",errMessage);
            }

            for(int j=0; j<nodesToInsertion.size(); j++){
                for (pugi::xml_node currNodeToInsert = newNode.first_child(); currNodeToInsert; currNodeToInsert = currNodeToInsert.next_sibling())
                {
                    nodesToInsertion[j].append_copy(currNodeToInsert); // append the new node
                }

            }

            UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@ADD_INSIDE_NODES");

            nodesToInsertion.clear();
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(filesToProcess.size(),"@ADD_INSIDE_NODES");
}

void XmlPatch::removeNodesOperation(XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){

    QVector<QString> filesToProcess;

    QList<pugi::xml_node> nodesToDeletion;

    try{

        filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);

        if(filesToProcess.isEmpty()){
            UtilXmlTools::displayErrorMessage("@REMOVE_NODES","No XML files were found for the wildcard: "+filesWildcard);
        }

        // Process all XmlFiles
        for(int i=0; i<filesToProcess.size(); i++){

            UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@REMOVE_NODES");

            // Check how the element will be fetched via element name or xpath expression
            if(xPathExpression.isEmpty()){
                UtilXmlTools::getAllNamedElements(this->rootNode,nodesToDeletion,filters);
            }
            else{
                UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToDeletion);
            }

            if(nodesToDeletion.isEmpty() || nodesToDeletion[0].type()==pugi::node_null){

                QString errMessage;

                if(xPathExpression.isEmpty()){
                    errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
                    if(filters.getParentElementName()!=""){
                        errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
                    }
                    if(filters.getAttributeName()!=""){
                        errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
                    }
                }
                else{
                    errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
                }

                UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
            }

            // Delete all the specified nodes
            for(int j=0; j<nodesToDeletion.size(); j++){
                if(!nodesToDeletion[j].parent().remove_child(nodesToDeletion[j])){  // remove the node

                    QString errMessage;
                    if(xPathExpression.isEmpty()){
                        errMessage = "Couldn't remove the node with Element '" + filters.getElementName() + "'";

                        if(filters.getParentElementName()!=""){
                            errMessage += " and a ParentElement: '" + filters.getParentElementName() + "'";
                        }
                    }
                    else{
                        errMessage = "Couldn't remove the node with the XPathExpression '" + xPathExpression + "'";
                    }

                    UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
                }
            }

            UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@REMOVE_NODES");

            nodesToDeletion.clear();
        }
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("@REMOVE_NODES", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@REMOVE_NODES");
}

void XmlPatch::executeCommandOperation(const QString &commandString){

    // Avoid infinite fork loops
    if(commandString.contains("-p ") || commandString.contains("--patch-files ")){
        UtilXmlTools::displayErrorMessage("@COMMAND","Use of --patch-files option is not allowed inside a patch file");
    }

    // Reserved to AEI
    if(commandString.contains("--aei-patch-files-list ")){
        UtilXmlTools::displayErrorMessage("@COMMAND","Use of --aei-patch-files-list option is not allowed inside a patch file");
    }

    std::cout << "@COMMAND patch operation output:\n"
              << "########################################################################"
              << std::endl;

    OptionsParser myParser(UtilXmlTools::QStringToArgsArray(commandString));
    myParser.parse();

    std::cout
            << "########################################################################"
            << std::endl;

    UtilXmlTools::displaySuccessMessage(1,"@COMMAND");
}

void XmlPatch::executeCustomCommandOperation(const QString &jsString, const QString &filesWildcard){

    QVector<QString> filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);

    try{
        if(filesToProcess.isEmpty()){
            UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","No XML files were found for the wildcard: "+filesWildcard);
        }

        XmlCustomCode::getInstance()->executeCustomCode(jsString,filesToProcess,this->backupsEnabled,this->verboseEnabled);
    }
    catch(const std::exception &e){
        UtilXmlTools::displayErrorMessage("@CUSTOM_CODE", QString("An exception was caught: ") + e.what());
    }

    UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@CUSTOM_CODE");
}

void XmlPatch::checkPatchVersion(const QString &file, QTextStream &fileStream){

    QString line, patchVersion="";

    // First get the patch version and check its validity
    while ( !fileStream.atEnd() ){
        line = fileStream.readLine();

        if(line.startsWith('#')){ // Ignore comments
            continue;
        }
        else if(line.startsWith("@XML_TOOLS")){

            patchVersion=getPatchParameterValue(line,"Version");

            if(!patchVersion.startsWith("2.0")){
                QString errMessage;

                errMessage = "The current patch version is incompatible with this XmlTools version:\n";
                errMessage += "Patch file name: '" + file + "'\n";
                errMessage += "XmlTools version:  " + GlobalVars::AppVersion + "\n" + "CurrPatch version: " + patchVersion + "";
                UtilXmlTools::displayErrorMessage("@XML_TOOLS",errMessage);
            }
            break; // We have got what we wanted
        }
    }

    if(patchVersion==""){
        UtilXmlTools::displayErrorMessage("@XML_TOOLS","Patch version not found.");
    }

}

void XmlPatch::checkAndProcessValidCommands(QTextStream &fileStream){

    QString line, filesWildcard;
    QString xmlToInsert, command, jsCode;
    QString xPathExpression;
    XmlFilter filters;

    // Process the rest of the commands in patch file
    while ( !fileStream.atEnd() ){
        line = fileStream.readLine();

        if(line.startsWith('#')){ // Ignore comments
            continue;
        }
        else if(line.startsWith("@ADD_INSIDE_NODES")){
            xPathExpression=getPatchParameterValue(line,"XPathExpression");
            filters.setElementName(getPatchParameterValue(line,"ElementName"));
            filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
            filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
            filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));

            if(this->forceTargetFilesWildcard!=""){
                filesWildcard=this->forceTargetFilesWildcard;
            }
            else{
                filesWildcard=getPatchParameterValue(line,"Files");
            }

            // Check options
            if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option or XPathExpression option is required.");
            }
            else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
            }
            if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeValue option is required if using AttributeName option.");
            }

            if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
                UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeName option is required if using AttributeValue option.");
            }

            while ( !fileStream.atEnd() && !line.startsWith("</xml>")){
                line = fileStream.readLine();

                if(!line.startsWith("<xml>") && !line.startsWith("</xml>")){
                    xmlToInsert += line + "\n";
                }
            }

            insertNodesOperation(xmlToInsert,filters,xPathExpression,filesWildcard);

            xmlToInsert.clear();
            filters.clear();
            xPathExpression.clear();
            filesWildcard.clear();
        }
        else if(line.startsWith("@REMOVE_NODES")){

            xPathExpression=getPatchParameterValue(line,"XPathExpression");
            filters.setElementName(getPatchParameterValue(line,"ElementName"));
            filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
            filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
            filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));

            if(this->forceTargetFilesWildcard!=""){
                filesWildcard=this->forceTargetFilesWildcard;
            }
            else{
                filesWildcard=getPatchParameterValue(line,"Files");
            }

            // Check options
            if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option or XPathExpression option is required.");
            }
            else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
            }

            if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeValue option is required if using AttributeName option.");
            }

            if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
                UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeName option is required if using AttributeValue option.");
            }

            removeNodesOperation(filters,xPathExpression,filesWildcard);

            filters.clear();
            xPathExpression.clear();
            filesWildcard.clear();
        }
        else if(line.startsWith("@COMMAND")){

            command=GlobalVars::AppExecutable;

            command+=" "+getPatchParameterValue(line,"Options");

            // Add --no-backups and --no-verbose if patch was called with that arguments
            if(!this->backupsEnabled){
                command.append(" --no-backups ");
            }

            if(!this->verboseEnabled){
                command.append(" --no-verbose ");
            }

            command.replace("'","\""); //replace apostrophe by quotes, to avoid problems
            command.replace("\"\"","'"); // this allow to use '' as ' ('' is transformed in "" and then in ')

            // Append files if forced to

            // This is added at the end so the apostrophe isn't done here (the path can contain it)
            if(!this->forceTargetFilesWildcard.isEmpty()){
                command+=" --files \""+this->forceTargetFilesWildcard+"\" ";
            }

            executeCommandOperation(command);

            command.clear();
            filesWildcard.clear();
        }
        else if(line.startsWith("@CUSTOM_CODE")){

            if(this->forceTargetFilesWildcard!=""){
                filesWildcard=this->forceTargetFilesWildcard;
            }
            else{
                filesWildcard=getPatchParameterValue(line,"Files");
            }

            while ( !fileStream.atEnd() && !line.startsWith("</code>")){

                line = fileStream.readLine();

                if(!line.startsWith("<code>") && !line.startsWith("</code>")){
                    jsCode += line + "\n";
                }
            }

            executeCustomCommandOperation(jsCode,filesWildcard);

            jsCode.clear();
            filesWildcard.clear();
        }
    }
}

QString XmlPatch::getPatchParameterValue(const QString& line, QString parameter){

    int startValueIdx, endValueIdx;

    parameter=" "+parameter+" "; // Parameters include a space before and after it's value.

    if(!line.contains(parameter)){
        if(parameter==" ParentElementName " || parameter==" AttributeName " || parameter==" AttributeValue "
                || parameter==" ElementName " || parameter==" XPathExpression "){
            return ""; // not mandatory
        }
        parameter.remove(" "); // just remove the space added so it doesn't look weird when outputted to the user

        UtilXmlTools::displayErrorMessage("Read patch file parameter","Couldn't retrieve '" + parameter + "' parameter.");
    }

    startValueIdx=line.indexOf(parameter); // get the position where parameter is defined
    endValueIdx=line.indexOf("\"",startValueIdx)+1; // get the position where parameter value begins (+1 to ignore mandotory quote)

    startValueIdx=endValueIdx;
    endValueIdx=line.indexOf("\"",startValueIdx); // get the last mandatory quote of the value

    return line.mid(startValueIdx,endValueIdx-startValueIdx); // return the value of the parameter (is in the middle of the mandatory quotes)
}
Revision:	1111
Committed:	Sat Feb 16 17:25:06 2019 UTC (6 years, 8 months ago) by s10k
Content type:	text/x-c++src
File size:	18755 byte(s)
Log Message:	Added version 2.0e (bugfix in patch file for paths with apostrophes)
#	Content
1	#include "xmlpatch.h"
2
3	XmlPatch::XmlPatch(QString patchFilesWildcard, QString forceTargetFilesWildcard, bool noBackups, bool noVerbose)
4	{
5	this->patchFilesToProcess=UtilXmlTools::getAllPatchFilesByWildcard(patchFilesWildcard);
6	this->forceTargetFilesWildcard=forceTargetFilesWildcard;
7	this->backupsEnabled=!noBackups;
8	this->verboseEnabled=!noVerbose;
9
10	if(forceTargetFilesWildcard!=""){
11	std::cout << "User forced patch in the target file(s): " << forceTargetFilesWildcard.toUtf8().constData() << std::endl;
12	}
13
14	if(this->patchFilesToProcess.isEmpty()){
15	UtilXmlTools::displayErrorMessage("Loading patch files","No .patch or .oni-patch files were found for the wildcard: "+patchFilesWildcard);
16	}
17
18	}
19
20	void XmlPatch::readAndProcessPatchFile(){
21
22	// Process all PatchFiles
23	for(int i=0; i<this->patchFilesToProcess.size(); i++){
24
25	QFile inputFile(this->patchFilesToProcess[i]);
26
27	if (inputFile.open(QIODevice::ReadOnly))
28	{
29
30	QTextStream fileStream(&inputFile);
31
32	checkPatchVersion(this->patchFilesToProcess[i], fileStream);
33	checkAndProcessValidCommands(fileStream);
34
35	inputFile.close();
36	}
37	else{
38	UtilXmlTools::displayErrorMessage("Read patch file", "Error opening patch file: '" + this->patchFilesToProcess[i] + "'.\n" + inputFile.errorString());
39	}
40
41	}
42
43	UtilXmlTools::displaySuccessMessage(this->patchFilesToProcess.size(),"Patch File(s)");
44
45	}
46
47	void XmlPatch::insertNodesOperation(const QString &xmlString, XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){
48
49	QVector<QString> filesToProcess;
50	QList<pugi::xml_node> nodesToInsertion;
51	pugi::xml_document newNode;
52	pugi::xml_parse_result result;
53
54	try{
55
56	filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
57
58	if(filesToProcess.isEmpty()){
59	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","No XML files were found for the wildcard: "+filesWildcard);
60	}
61
62	result=newNode.load(xmlString.toUtf8().constData()); // load xml to insert
63
64	if(result.status!=pugi::status_ok){
65	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES", "The xml node to insert is invalid.\n" + QString(result.description()));
66	}
67
68	// Process all XmlFiles
69	for(int i=0; i<filesToProcess.size(); i++){
70
71	UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@ADD_INSIDE_NODES");
72
73	// Check how the element will be fetched via element name or xpath expression
74	if(xPathExpression.isEmpty()){
75	UtilXmlTools::getAllNamedElements(this->rootNode,nodesToInsertion,filters);
76	}
77	else{
78	UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToInsertion);
79	}
80
81	if(nodesToInsertion.isEmpty() \|\| nodesToInsertion[0].type()==pugi::node_null){
82
83	QString errMessage;
84
85	if(xPathExpression.isEmpty()){
86	errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
87	if(filters.getParentElementName()!=""){
88	errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
89	}
90	if(filters.getAttributeName()!=""){
91	errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
92	}
93	}
94	else{
95	errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
96	}
97
98	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES",errMessage);
99	}
100
101	for(int j=0; j<nodesToInsertion.size(); j++){
102	for (pugi::xml_node currNodeToInsert = newNode.first_child(); currNodeToInsert; currNodeToInsert = currNodeToInsert.next_sibling())
103	{
104	nodesToInsertion[j].append_copy(currNodeToInsert); // append the new node
105	}
106
107	}
108
109	UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@ADD_INSIDE_NODES");
110
111	nodesToInsertion.clear();
112	}
113	}
114	catch(const std::exception &e){
115	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES", QString("An exception was caught: ") + e.what());
116	}
117
118	UtilXmlTools::displaySuccessMessage(filesToProcess.size(),"@ADD_INSIDE_NODES");
119	}
120
121	void XmlPatch::removeNodesOperation(XmlFilter &filters, const QString &xPathExpression, const QString &filesWildcard){
122
123	QVector<QString> filesToProcess;
124
125	QList<pugi::xml_node> nodesToDeletion;
126
127	try{
128
129	filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
130
131	if(filesToProcess.isEmpty()){
132	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","No XML files were found for the wildcard: "+filesWildcard);
133	}
134
135	// Process all XmlFiles
136	for(int i=0; i<filesToProcess.size(); i++){
137
138	UtilXmlTools::loadXmlFile(filesToProcess[i],this->document,this->rootNode,this->backupsEnabled,this->verboseEnabled,"@REMOVE_NODES");
139
140	// Check how the element will be fetched via element name or xpath expression
141	if(xPathExpression.isEmpty()){
142	UtilXmlTools::getAllNamedElements(this->rootNode,nodesToDeletion,filters);
143	}
144	else{
145	UtilXmlTools::getAllXpathElements(xPathExpression,this->document,nodesToDeletion);
146	}
147
148	if(nodesToDeletion.isEmpty() \|\| nodesToDeletion[0].type()==pugi::node_null){
149
150	QString errMessage;
151
152	if(xPathExpression.isEmpty()){
153	errMessage = "No node was found with an ElementName: '" + filters.getElementName() + "'";
154	if(filters.getParentElementName()!=""){
155	errMessage += " and a ParentElementName: '" + filters.getParentElementName() + "'";
156	}
157	if(filters.getAttributeName()!=""){
158	errMessage += " and an AttributeName: '" + filters.getAttributeName() + "' and an AttributeValue: '" + filters.getAttributeValue() + "'";
159	}
160	}
161	else{
162	errMessage = "No node was found with an XPathExpression: '" + xPathExpression + "'";
163	}
164
165	UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
166	}
167
168	// Delete all the specified nodes
169	for(int j=0; j<nodesToDeletion.size(); j++){
170	if(!nodesToDeletion[j].parent().remove_child(nodesToDeletion[j])){ // remove the node
171
172	QString errMessage;
173	if(xPathExpression.isEmpty()){
174	errMessage = "Couldn't remove the node with Element '" + filters.getElementName() + "'";
175
176	if(filters.getParentElementName()!=""){
177	errMessage += " and a ParentElement: '" + filters.getParentElementName() + "'";
178	}
179	}
180	else{
181	errMessage = "Couldn't remove the node with the XPathExpression '" + xPathExpression + "'";
182	}
183
184	UtilXmlTools::displayErrorMessage("@REMOVE_NODES",errMessage);
185	}
186	}
187
188	UtilXmlTools::saveXmlFile(filesToProcess[i],this->document, "@REMOVE_NODES");
189
190	nodesToDeletion.clear();
191	}
192	}
193	catch(const std::exception &e){
194	UtilXmlTools::displayErrorMessage("@REMOVE_NODES", QString("An exception was caught: ") + e.what());
195	}
196
197	UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@REMOVE_NODES");
198	}
199
200	void XmlPatch::executeCommandOperation(const QString &commandString){
201
202	// Avoid infinite fork loops
203	if(commandString.contains("-p ") \|\| commandString.contains("--patch-files ")){
204	UtilXmlTools::displayErrorMessage("@COMMAND","Use of --patch-files option is not allowed inside a patch file");
205	}
206
207	// Reserved to AEI
208	if(commandString.contains("--aei-patch-files-list ")){
209	UtilXmlTools::displayErrorMessage("@COMMAND","Use of --aei-patch-files-list option is not allowed inside a patch file");
210	}
211
212	std::cout << "@COMMAND patch operation output:\n"
213	<< "########################################################################"
214	<< std::endl;
215
216	OptionsParser myParser(UtilXmlTools::QStringToArgsArray(commandString));
217	myParser.parse();
218
219	std::cout
220	<< "########################################################################"
221	<< std::endl;
222
223	UtilXmlTools::displaySuccessMessage(1,"@COMMAND");
224	}
225
226	void XmlPatch::executeCustomCommandOperation(const QString &jsString, const QString &filesWildcard){
227
228	QVector<QString> filesToProcess=UtilXmlTools::getAllXmlFilesByWildcard(filesWildcard);
229
230	try{
231	if(filesToProcess.isEmpty()){
232	UtilXmlTools::displayErrorMessage("@CUSTOM_CODE","No XML files were found for the wildcard: "+filesWildcard);
233	}
234
235	XmlCustomCode::getInstance()->executeCustomCode(jsString,filesToProcess,this->backupsEnabled,this->verboseEnabled);
236	}
237	catch(const std::exception &e){
238	UtilXmlTools::displayErrorMessage("@CUSTOM_CODE", QString("An exception was caught: ") + e.what());
239	}
240
241	UtilXmlTools::displaySuccessMessage(filesToProcess.size(), "@CUSTOM_CODE");
242	}
243
244	void XmlPatch::checkPatchVersion(const QString &file, QTextStream &fileStream){
245
246	QString line, patchVersion="";
247
248	// First get the patch version and check its validity
249	while ( !fileStream.atEnd() ){
250	line = fileStream.readLine();
251
252	if(line.startsWith('#')){ // Ignore comments
253	continue;
254	}
255	else if(line.startsWith("@XML_TOOLS")){
256
257	patchVersion=getPatchParameterValue(line,"Version");
258
259	if(!patchVersion.startsWith("2.0")){
260	QString errMessage;
261
262	errMessage = "The current patch version is incompatible with this XmlTools version:\n";
263	errMessage += "Patch file name: '" + file + "'\n";
264	errMessage += "XmlTools version: " + GlobalVars::AppVersion + "\n" + "CurrPatch version: " + patchVersion + "";
265	UtilXmlTools::displayErrorMessage("@XML_TOOLS",errMessage);
266	}
267	break; // We have got what we wanted
268	}
269	}
270
271	if(patchVersion==""){
272	UtilXmlTools::displayErrorMessage("@XML_TOOLS","Patch version not found.");
273	}
274
275	}
276
277	void XmlPatch::checkAndProcessValidCommands(QTextStream &fileStream){
278
279	QString line, filesWildcard;
280	QString xmlToInsert, command, jsCode;
281	QString xPathExpression;
282	XmlFilter filters;
283
284	// Process the rest of the commands in patch file
285	while ( !fileStream.atEnd() ){
286	line = fileStream.readLine();
287
288	if(line.startsWith('#')){ // Ignore comments
289	continue;
290	}
291	else if(line.startsWith("@ADD_INSIDE_NODES")){
292	xPathExpression=getPatchParameterValue(line,"XPathExpression");
293	filters.setElementName(getPatchParameterValue(line,"ElementName"));
294	filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
295	filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
296	filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));
297
298	if(this->forceTargetFilesWildcard!=""){
299	filesWildcard=this->forceTargetFilesWildcard;
300	}
301	else{
302	filesWildcard=getPatchParameterValue(line,"Files");
303	}
304
305	// Check options
306	if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
307	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option or XPathExpression option is required.");
308	}
309	else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
310	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
311	}
312	if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
313	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeValue option is required if using AttributeName option.");
314	}
315
316	if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
317	UtilXmlTools::displayErrorMessage("@ADD_INSIDE_NODES","AttributeName option is required if using AttributeValue option.");
318	}
319
320	while ( !fileStream.atEnd() && !line.startsWith("</xml>")){
321	line = fileStream.readLine();
322
323	if(!line.startsWith("<xml>") && !line.startsWith("</xml>")){
324	xmlToInsert += line + "\n";
325	}
326	}
327
328	insertNodesOperation(xmlToInsert,filters,xPathExpression,filesWildcard);
329
330	xmlToInsert.clear();
331	filters.clear();
332	xPathExpression.clear();
333	filesWildcard.clear();
334	}
335	else if(line.startsWith("@REMOVE_NODES")){
336
337	xPathExpression=getPatchParameterValue(line,"XPathExpression");
338	filters.setElementName(getPatchParameterValue(line,"ElementName"));
339	filters.setParentElementName(getPatchParameterValue(line,"ParentElementName"));
340	filters.setAttributeName(getPatchParameterValue(line,"AttributeName"));
341	filters.setAttributeValue(getPatchParameterValue(line,"AttributeValue"));
342
343	if(this->forceTargetFilesWildcard!=""){
344	filesWildcard=this->forceTargetFilesWildcard;
345	}
346	else{
347	filesWildcard=getPatchParameterValue(line,"Files");
348	}
349
350	// Check options
351	if(xPathExpression.isEmpty() && filters.getElementName().isEmpty()){
352	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option or XPathExpression option is required.");
353	}
354	else if(!xPathExpression.isEmpty() && !filters.getElementName().isEmpty()){
355	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","ElementName option and XPathExpression option cannot be used simultaneously.");
356	}
357
358	if(filters.getAttributeName()!="" && filters.getAttributeValue()==""){
359	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeValue option is required if using AttributeName option.");
360	}
361
362	if(filters.getAttributeValue()!="" && filters.getAttributeName()==""){
363	UtilXmlTools::displayErrorMessage("@REMOVE_NODES","AttributeName option is required if using AttributeValue option.");
364	}
365
366	removeNodesOperation(filters,xPathExpression,filesWildcard);
367
368	filters.clear();
369	xPathExpression.clear();
370	filesWildcard.clear();
371	}
372	else if(line.startsWith("@COMMAND")){
373
374	command=GlobalVars::AppExecutable;
375
376	command+=" "+getPatchParameterValue(line,"Options");
377
378	// Add --no-backups and --no-verbose if patch was called with that arguments
379	if(!this->backupsEnabled){
380	command.append(" --no-backups ");
381	}
382
383	if(!this->verboseEnabled){
384	command.append(" --no-verbose ");
385	}
386
387	command.replace("'","\""); //replace apostrophe by quotes, to avoid problems
388	command.replace("\"\"","'"); // this allow to use '' as ' ('' is transformed in "" and then in ')
389
390	// Append files if forced to
391
392	// This is added at the end so the apostrophe isn't done here (the path can contain it)
393	if(!this->forceTargetFilesWildcard.isEmpty()){
394	command+=" --files \""+this->forceTargetFilesWildcard+"\" ";
395	}
396
397	executeCommandOperation(command);
398
399	command.clear();
400	filesWildcard.clear();
401	}
402	else if(line.startsWith("@CUSTOM_CODE")){
403
404	if(this->forceTargetFilesWildcard!=""){
405	filesWildcard=this->forceTargetFilesWildcard;
406	}
407	else{
408	filesWildcard=getPatchParameterValue(line,"Files");
409	}
410
411	while ( !fileStream.atEnd() && !line.startsWith("</code>")){
412
413	line = fileStream.readLine();
414
415	if(!line.startsWith("<code>") && !line.startsWith("</code>")){
416	jsCode += line + "\n";
417	}
418	}
419
420	executeCustomCommandOperation(jsCode,filesWildcard);
421
422	jsCode.clear();
423	filesWildcard.clear();
424	}
425	}
426	}
427
428	QString XmlPatch::getPatchParameterValue(const QString& line, QString parameter){
429
430	int startValueIdx, endValueIdx;
431
432	parameter=" "+parameter+" "; // Parameters include a space before and after it's value.
433
434	if(!line.contains(parameter)){
435	if(parameter==" ParentElementName " \|\| parameter==" AttributeName " \|\| parameter==" AttributeValue "
436	\|\| parameter==" ElementName " \|\| parameter==" XPathExpression "){
437	return ""; // not mandatory
438	}
439	parameter.remove(" "); // just remove the space added so it doesn't look weird when outputted to the user
440
441	UtilXmlTools::displayErrorMessage("Read patch file parameter","Couldn't retrieve '" + parameter + "' parameter.");
442	}
443
444	startValueIdx=line.indexOf(parameter); // get the position where parameter is defined
445	endValueIdx=line.indexOf("\"",startValueIdx)+1; // get the position where parameter value begins (+1 to ignore mandotory quote)
446
447	startValueIdx=endValueIdx;
448	endValueIdx=line.indexOf("\"",startValueIdx); // get the last mandatory quote of the value
449
450	return line.mid(startValueIdx,endValueIdx-startValueIdx); // return the value of the parameter (is in the middle of the mandatory quotes)
451	}