bool PinotSettings::loadFilePatterns(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
// Load the file patterns list
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "pattern")
{
m_filePatternsBlackList.insert(nodeContent);
}
}
return true;
}
bool PinotSettings::loadLabels(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
// Load the label's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
m_labels.insert(nodeContent);
}
// Labels used to have colours...
}
return true;
}
bool PinotSettings::loadUi(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "xpos")
{
m_xPos = atoi(nodeContent.c_str());
}
else if (nodeName == "ypos")
{
m_yPos = atoi(nodeContent.c_str());
}
else if (nodeName == "width")
{
m_width = atoi(nodeContent.c_str());
}
else if (nodeName == "height")
{
m_height = atoi(nodeContent.c_str());
}
else if (nodeName == "panepos")
{
m_panePos = atoi(nodeContent.c_str());
}
else if (nodeName == "expandqueries")
{
if (nodeContent == "YES")
{
m_expandQueries = true;
}
else
{
m_expandQueries = false;
}
}
}
return true;
}
bool PinotSettings::loadMailAccounts(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
MailAccount mailAccount;
// Load the mail account's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
mailAccount.m_name = nodeContent;
}
else if (nodeName == "type")
{
mailAccount.m_type = nodeContent;
}
else if (nodeName == "mtime")
{
mailAccount.m_modTime = (time_t)atoi(nodeContent.c_str());
}
else if (nodeName == "mindate")
{
mailAccount.m_lastMessageTime = (time_t)atoi(nodeContent.c_str());
}
else if (nodeName == "size")
{
mailAccount.m_size = (off_t)atoi(nodeContent.c_str());
}
}
if (mailAccount.m_name.empty() == false)
{
m_mailAccounts.insert(mailAccount);
}
return true;
}
bool PinotSettings::loadLabels(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
Label label;
// Load the label's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
label.m_name = nodeContent;
}
else if (nodeName == "red")
{
label.m_red = (unsigned short)atoi(nodeContent.c_str());
}
else if (nodeName == "green")
{
label.m_green = (unsigned short)atoi(nodeContent.c_str());
}
else if (nodeName == "blue")
{
label.m_blue = (unsigned short)atoi(nodeContent.c_str());
}
}
if (label.m_name.empty() == false)
{
m_labels.insert(label);
}
return true;
}
bool PinotSettings::loadProxy(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pChildElem = dynamic_cast<Element*>(pNode);
if (pChildElem == NULL)
{
continue;
}
string nodeName(pChildElem->get_name());
string nodeContent(getElementContent(pChildElem));
if (nodeName == "address")
{
m_proxyAddress = nodeContent;
}
else if (nodeName == "port")
{
m_proxyPort = (unsigned int)atoi(nodeContent.c_str());
}
else if (nodeName == "type")
{
m_proxyType = nodeContent;
}
else if (nodeName == "enable")
{
if (nodeContent == "YES")
{
m_proxyEnabled = true;
}
else
{
m_proxyEnabled = false;
}
}
}
return true;
}
bool PinotSettings::loadIndexableLocations(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
IndexableLocation location;
// Load the indexable location's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
location.m_name = nodeContent;
}
else if (nodeName == "monitor")
{
if (nodeContent == "YES")
{
location.m_monitor = true;
}
else
{
location.m_monitor = false;
}
}
}
if (location.m_name.empty() == false)
{
m_indexableLocations.insert(location);
}
return true;
}
bool PinotSettings::loadIndexes(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
string indexName, indexLocation;
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
indexName = nodeContent;
}
else if (nodeName == "location")
{
indexLocation = nodeContent;
}
}
if ((indexName.empty() == false) &&
(indexLocation.empty() == false))
{
addIndex(indexName, indexLocation);
}
return true;
}
bool PinotSettings::loadColour(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
// Load the colour RGB components
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
gushort value = (gushort)atoi(nodeContent.c_str());
if (nodeName == "red")
{
m_newResultsColourRed = value;
}
else if (nodeName == "green")
{
m_newResultsColourGreen = value;
}
else if (nodeName == "blue")
{
m_newResultsColourBlue = value;
}
}
return true;
}
bool PinotSettings::loadResults(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "viewmode")
{
if (nodeContent == "SOURCE")
{
m_browseResults = false;
}
else
{
m_browseResults = true;
}
}
else if (nodeName == "browser")
{
m_browserCommand = nodeContent;
}
}
return true;
}
string XmlReader::getTextFromElement(const Element* elementNode, const string& childName, bool required) const {
string text;
const Node::NodeList children = elementNode->get_children(childName);
if (children.size() == 1) {
const Element *elementChild = castToElement(children.front());
for (const Node *child : elementChild->get_children()) {
const TextNode* textNode = dynamic_cast<const TextNode*>(child);
if (textNode != nullptr) {
if (!textNode->is_white_space())
text += textNode->get_content();
} else {
throw InvalidDatasetFile(caller(), "Invalid cast to 'TextNode*' type!", (child != nullptr ? child->get_line() : -1));
}
}
} else if (children.size() > 1) {
throw InvalidDatasetFile(caller(), "Only from one child the text can be retrieved!", elementNode->get_line());
} else if (children.empty() && required) {
string msg = "Cannot find the '"+string(childName)+"' element!\n";
throw InvalidDatasetFile(caller(), msg+"Invalid input xml file!", elementNode->get_line());
}
return text;
}
bool PinotSettings::loadEngineChannels(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
std::map<string, bool>::iterator channelIter = m_engineChannels.find(nodeContent);
if (channelIter != m_engineChannels.end())
{
channelIter->second = false;
}
}
}
return true;
}
bool PinotSettings::loadQueries(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
QueryProperties queryProps;
Date minDate, maxDate;
string freeQuery;
bool enableMinDate = false, enableMaxDate = false;
// Load the query's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pChildElem = dynamic_cast<Element*>(pNode);
if (pChildElem == NULL)
{
continue;
}
string nodeName(pChildElem->get_name());
string nodeContent(getElementContent(pChildElem));
if (nodeName == "name")
{
queryProps.setName(nodeContent);
}
else if (nodeName == "sortorder")
{
if (nodeContent == "DATE")
{
queryProps.setSortOrder(QueryProperties::DATE);
}
else
{
queryProps.setSortOrder(QueryProperties::RELEVANCE);
}
}
else if (nodeName == "text")
{
freeQuery = nodeContent;
}
else if ((nodeName == "and") &&
(nodeContent.empty() == false))
{
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += nodeContent;
}
else if ((nodeName == "phrase") &&
(nodeContent.empty() == false))
{
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += "\"";
freeQuery += nodeContent;
freeQuery += "\"";
}
else if ((nodeName == "any") &&
(nodeContent.empty() == false))
{
// FIXME: don't be lazy and add those correctly
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += nodeContent;
}
else if ((nodeName == "not") &&
(nodeContent.empty() == false))
{
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += "-(";
freeQuery += nodeContent;
freeQuery += ")";
}
else if ((nodeName == "language") &&
(nodeContent.empty() == false))
{
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += "lang:";
freeQuery += nodeContent;
}
else if ((nodeName == "stemlanguage") &&
(nodeContent.empty() == false))
{
queryProps.setStemmingLanguage(Languages::toLocale(nodeContent));
}
else if ((nodeName == "hostfilter") &&
(nodeContent.empty() == false))
{
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += "site:";
freeQuery += nodeContent;
}
else if ((nodeName == "filefilter") &&
(nodeContent.empty() == false))
{
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += "file:";
freeQuery += nodeContent;
}
else if ((nodeName == "labelfilter") &&
(nodeContent.empty() == false))
{
if (freeQuery.empty() == false)
{
freeQuery += " ";
}
freeQuery += "label:";
freeQuery += nodeContent;
}
else if (nodeName == "maxresults")
{
int count = atoi(nodeContent.c_str());
queryProps.setMaximumResultsCount((unsigned int)max(count, 10));
}
else if (nodeName == "enablemindate")
{
if (nodeContent == "YES")
{
enableMinDate = true;
}
}
else if (nodeName == "mindate")
{
minDate.set_parse(nodeContent);
}
else if (nodeName == "enablemaxdate")
{
if (nodeContent == "YES")
{
enableMaxDate = true;
}
}
else if (nodeName == "maxdate")
{
maxDate.set_parse(nodeContent);
}
else if (nodeName == "index")
{
if (nodeContent == "NEW")
{
queryProps.setIndexResults(QueryProperties::NEW_RESULTS);
}
else if (nodeContent == "ALL")
{
queryProps.setIndexResults(QueryProperties::ALL_RESULTS);
}
else
{
queryProps.setIndexResults(QueryProperties::NOTHING);
}
}
else if (nodeName == "label")
{
queryProps.setLabelName(nodeContent);
}
else if (nodeName == "modified")
{
if (nodeContent == "YES")
{
queryProps.setModified(true);
}
}
}
// Are pre-0.80 dates specified ?
if ((enableMinDate == true) ||
(enableMaxDate == true))
{
// Provide reasonable defaults
if (enableMinDate == false)
{
minDate.set_day(1);
minDate.set_month(Date::JANUARY);
minDate.set_year(1970);
}
if (enableMaxDate == false)
{
maxDate.set_day(31);
maxDate.set_month(Date::DECEMBER);
maxDate.set_year(2099);
}
ustring minDateStr(minDate.format_string("%Y%m%d"));
ustring maxDateStr(maxDate.format_string("%Y%m%d"));
#ifdef DEBUG
cout << "PinotSettings::loadQueries: date range " << minDateStr << " to " << maxDateStr << endl;
#endif
freeQuery += " ";
freeQuery += minDateStr;
freeQuery += "..";
freeQuery += maxDateStr;
}
// We need at least a name
if (queryProps.getName().empty() == false)
{
if (freeQuery.empty() == false)
{
queryProps.setFreeQuery(freeQuery);
}
m_queries[queryProps.getName()] = queryProps;
}
return true;
}
iPackage* JispParser::parse(const FindFile::Found& defFile) {
using namespace xmlpp;
// parsujemy xmla z definicjami
DomParser parser;
parser.set_substitute_entities();
Node* rootNode;
Node* metaNode;
Node::NodeList icons;
Node::NodeList nodes;
Attribute* attrib;
eMSet result;
ifstream file(defFile.getFilePath().c_str());
try {
parser.parse_stream(file);
} catch (const xmlpp::exception& e) {
throw XMLParserException(e.what());
}
file.close();
rootNode = parser.get_document()->get_root_node();
if (rootNode->get_name() != "icondef") throw WrongFormat("Z³a nazwa korzenia dokumentu (z³y format ?)");
nodes = rootNode->get_children("meta");
if (nodes.size() != 1) throw WrongFormat("Nie ma dok³adnie jednego elementu 'meta'");
metaNode = *nodes.begin();
if (!metaNode) throw WrongFormat("Element 'meta' nie zawiera dzieci");
nodes = metaNode->get_children("name");
if (nodes.size() == 1 && dynamic_cast<Element*>(*nodes.begin())) {
result.setName(dynamic_cast<Element*>(*nodes.begin())->get_child_text()->get_content().c_str());
}
nodes = metaNode->get_children("version");
if (nodes.size() == 1 && dynamic_cast<Element*>(*nodes.begin())) {
result.setVersion(dynamic_cast<Element*>(*nodes.begin())->get_child_text()->get_content().c_str());
}
nodes = metaNode->get_children("description");
if (nodes.size() == 1 && dynamic_cast<Element*>(*nodes.begin())) {
result.setDescription(dynamic_cast<Element*>(*nodes.begin())->get_child_text()->get_content().c_str());
}
nodes = metaNode->get_children("author");
for (Node::NodeList::iterator it = nodes.begin(); it != nodes.end(); it++) {
if (dynamic_cast<Element*>(*it)) {
attrib = dynamic_cast<Element*>(*it)->get_attribute("jid");
result.addAuthor(eMAuthor(dynamic_cast<Element*>(*it)->get_child_text()->get_content().c_str(),
attrib ? attrib->get_value().c_str() : ""));
}
}
nodes = metaNode->get_children("creation");
if (nodes.size() == 1 && dynamic_cast<Element*>(*nodes.begin())) {
// result.setCTime(dynamic_cast<Element*>(*nodes.begin())->get_child_text()->get_content().c_str());
}
nodes = metaNode->get_children("home");
if (nodes.size() == 1 && dynamic_cast<Element*>(*nodes.begin())) {
result.setUrl(dynamic_cast<Element*>(*nodes.begin())->get_child_text()->get_content().c_str());
}
icons = rootNode->get_children("icon");
for (Node::NodeList::iterator it = icons.begin(); it != icons.end(); it++) {
eM emot(true, false);
string mime;
nodes = (*it)->get_children("object");
for (Node::NodeList::iterator it = nodes.begin(); it != nodes.end(); it++) {
if (dynamic_cast<Element*>(*it) && dynamic_cast<Element*>(*it)->get_attribute("mime")) {
mime = dynamic_cast<Element*>(*it)->get_attribute("mime")->get_value();
if (mime == "image/png" || mime == "image/gif" || mime == "image/jpeg") {
emot.setImgPath(defFile.getDirectory() + (string) dynamic_cast<Element*>(*it)->get_child_text()->get_content());
break;
}
mime.clear();
}
}
if (mime.empty()) continue;
nodes = (*it)->get_children("text");
if (nodes.empty()) throw WrongFormat("Brak tekstu do zamiany");
for (Node::NodeList::iterator it = nodes.begin(); it != nodes.end(); it++) {
if (dynamic_cast<Element*>(*it)) {
emot.setText(dynamic_cast<Element*>(*it)->get_child_text()->get_content().c_str());
attrib = dynamic_cast<Element*>(*it)->get_attribute("regexp");
if (attrib) {
emot.setPreg((bool) atoi(attrib->get_value().c_str()));
}
result.addEmot(emot);
}
}
}
return new eMSet(result);
}
bool PinotSettings::loadQueries(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
QueryProperties queryProps;
// Load the query's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
queryProps.setName(nodeContent);
}
else if (nodeName == "and")
{
queryProps.setAndWords(nodeContent);
}
else if (nodeName == "phrase")
{
queryProps.setPhrase(nodeContent);
}
else if (nodeName == "any")
{
queryProps.setAnyWords(nodeContent);
}
else if (nodeName == "not")
{
queryProps.setNotWords(nodeContent);
}
else if (nodeName == "language")
{
queryProps.setLanguage(Languages::toLocale(nodeContent));
}
else if (nodeName == "hostfilter")
{
queryProps.setHostFilter(nodeContent);
}
else if (nodeName == "filefilter")
{
queryProps.setFileFilter(nodeContent);
}
else if (nodeName == "labelfilter")
{
queryProps.setLabelFilter(nodeContent);
}
else if (nodeName == "maxresults")
{
int count = atoi(nodeContent.c_str());
queryProps.setMaximumResultsCount((unsigned int)max(count, 10));
}
else if (nodeName == "index")
{
if (nodeContent == "ALL")
{
queryProps.setIndexResults(true);
}
else
{
queryProps.setIndexResults(false);
}
}
else if (nodeName == "label")
{
queryProps.setLabelName(nodeContent);
}
}
// We need at least a name
if (queryProps.getName().empty() == false)
{
m_queries[queryProps.getName()] = queryProps;
}
return true;
}
bool PinotSettings::loadQueries(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
QueryProperties queryProps;
string backCompatString;
// Load the query's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
queryProps.setName(nodeContent);
}
else if (nodeName == "text")
{
queryProps.setFreeQuery(nodeContent);
}
else if ((nodeName == "and") &&
(nodeContent.empty() == false))
{
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += nodeContent;
}
else if ((nodeName == "phrase") &&
(nodeContent.empty() == false))
{
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += "\"";
backCompatString += nodeContent;
backCompatString += "\"";
}
else if ((nodeName == "any") &&
(nodeContent.empty() == false))
{
// FIXME: don't be lazy and add those correctly
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += nodeContent;
}
else if ((nodeName == "not") &&
(nodeContent.empty() == false))
{
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += "-(";
backCompatString += nodeContent;
backCompatString += ")";
}
else if ((nodeName == "language") &&
(nodeContent.empty() == false))
{
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += "language:";
backCompatString += nodeContent;
}
else if ((nodeName == "hostfilter") &&
(nodeContent.empty() == false))
{
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += "site:";
backCompatString += nodeContent;
}
else if ((nodeName == "filefilter") &&
(nodeContent.empty() == false))
{
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += "file:";
backCompatString += nodeContent;
}
else if ((nodeName == "labelfilter") &&
(nodeContent.empty() == false))
{
if (backCompatString.empty() == false)
{
backCompatString += " ";
}
backCompatString += "label:";
backCompatString += nodeContent;
}
else if (nodeName == "maxresults")
{
int count = atoi(nodeContent.c_str());
queryProps.setMaximumResultsCount((unsigned int)max(count, 10));
}
else if (nodeName == "index")
{
if (nodeContent == "ALL")
{
queryProps.setIndexResults(true);
}
else
{
queryProps.setIndexResults(false);
}
}
else if (nodeName == "label")
{
queryProps.setLabelName(nodeContent);
}
}
// We need at least a name
if (queryProps.getName().empty() == false)
{
if (backCompatString.empty() == false)
{
queryProps.setFreeQuery(backCompatString);
}
m_queries[queryProps.getName()] = queryProps;
}
return true;
}
bool PinotSettings::loadConfiguration(const std::string &fileName, bool isGlobal)
{
struct stat fileStat;
bool success = true;
if ((stat(fileName.c_str(), &fileStat) != 0) ||
(!S_ISREG(fileStat.st_mode)))
{
cerr << "Couldn' open configuration file " << fileName << endl;
return false;
}
try
{
// Parse the configuration file
DomParser parser;
parser.set_substitute_entities(true);
parser.parse_file(fileName);
xmlpp::Document *pDocument = parser.get_document();
if (pDocument == NULL)
{
return false;
}
Element *pRootElem = pDocument->get_root_node();
if (pRootElem == NULL)
{
return false;
}
// Check the top-level element is what we expect
ustring rootNodeName = pRootElem->get_name();
if (rootNodeName != "pinot")
{
return false;
}
// Go through the subnodes
const Node::NodeList childNodes = pRootElem->get_children();
if (childNodes.empty() == false)
{
for (Node::NodeList::const_iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
// All nodes should be elements
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName(pElem->get_name());
string nodeContent(getElementContent(pElem));
if (isGlobal == true)
{
if (nodeName == "cache")
{
loadCacheProviders(pElem);
}
else
{
// Unsupported element
continue;
}
}
else if (nodeName == "googleapikey")
{
m_googleAPIKey = nodeContent;
}
else if (nodeName == "ui")
{
loadUi(pElem);
}
else if (nodeName == "extraindex")
{
loadIndexes(pElem);
}
else if (nodeName == "channel")
{
loadEngineChannels(pElem);
}
else if (nodeName == "storedquery")
{
loadQueries(pElem);
}
else if (nodeName == "label")
{
loadLabels(pElem);
}
else if (nodeName == "robots")
{
if (nodeContent == "IGNORE")
{
m_ignoreRobotsDirectives = true;
}
else
{
m_ignoreRobotsDirectives = false;
}
}
else if (nodeName == "suggestterms")
{
if (nodeContent == "YES")
{
m_suggestQueryTerms = true;
}
else
{
m_suggestQueryTerms = false;
}
}
else if (nodeName == "newresults")
{
loadColour(pElem);
}
else if (nodeName == "mailaccount")
{
loadMailAccounts(pElem);
}
else if (nodeName == "indexable")
{
loadIndexableLocations(pElem);
}
}
}
}
catch (const std::exception& ex)
{
cerr << "Couldn't parse configuration file: "
<< ex.what() << endl;
success = false;
}
return success;
}
bool PinotSettings::loadCacheProviders(const Element *pElem)
{
if (pElem == NULL)
{
return false;
}
Node::NodeList childNodes = pElem->get_children();
if (childNodes.empty() == true)
{
return false;
}
CacheProvider cacheProvider;
// Load the cache provider's properties
for (Node::NodeList::iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "name")
{
cacheProvider.m_name = nodeContent;
}
else if (nodeName == "location")
{
cacheProvider.m_location = nodeContent;
}
else if (nodeName == "protocols")
{
nodeContent += ",";
ustring::size_type previousPos = 0, commaPos = nodeContent.find(",");
while (commaPos != ustring::npos)
{
string protocol(nodeContent.substr(previousPos,
commaPos - previousPos));
StringManip::trimSpaces(protocol);
cacheProvider.m_protocols.insert(protocol);
// Next
previousPos = commaPos + 1;
commaPos = nodeContent.find(",", previousPos);
}
}
}
if ((cacheProvider.m_name.empty() == false) &&
(cacheProvider.m_location.empty() == false))
{
m_cacheProviders.push_back(cacheProvider);
// Copy the list of protocols supported by this cache provider
copy(cacheProvider.m_protocols.begin(), cacheProvider.m_protocols.end(),
inserter(m_cacheProtocols, m_cacheProtocols.begin()));
}
return true;
}
bool PinotSettings::loadConfiguration(const std::string &fileName)
{
struct stat fileStat;
bool success = true;
if ((stat(fileName.c_str(), &fileStat) != 0) ||
(!S_ISREG(fileStat.st_mode)))
{
return false;
}
try
{
// Parse the configuration file
DomParser parser;
parser.set_substitute_entities(true);
parser.parse_file(fileName);
xmlpp::Document *pDocument = parser.get_document();
if (pDocument == NULL)
{
return false;
}
Element *pRootElem = pDocument->get_root_node();
if (pRootElem == NULL)
{
return false;
}
// Check the top-level element is what we expect
ustring rootNodeName = pRootElem->get_name();
if (rootNodeName != "pinot")
{
return false;
}
// Go through the subnodes
const Node::NodeList childNodes = pRootElem->get_children();
if (childNodes.empty() == false)
{
for (Node::NodeList::const_iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pNode = (*iter);
// All nodes should be elements
Element *pElem = dynamic_cast<Element*>(pNode);
if (pElem == NULL)
{
continue;
}
string nodeName = pElem->get_name();
string nodeContent = getElementContent(pElem);
if (nodeName == "googleapikey")
{
m_googleAPIKey = nodeContent;
}
else if (nodeName == "ui")
{
if (loadUi(pElem) == false)
{
cerr << _("Couldn't load ui block") << endl;
}
}
else if (nodeName == "extraindex")
{
if (loadIndexes(pElem) == false)
{
cerr << _("Couldn't load extraindex block") << endl;
}
}
else if (nodeName == "storedquery")
{
if (loadQueries(pElem) == false)
{
cerr << _("Couldn't load storedquery block") << endl;
}
}
else if (nodeName == "results")
{
if (loadResults(pElem) == false)
{
cerr << _("Couldn't load results block") << endl;
}
}
else if (nodeName == "label")
{
if (loadLabels(pElem) == false)
{
cerr << _("Couldn't load label block") << endl;
}
}
else if (nodeName == "robots")
{
if (nodeContent == "IGNORE")
{
m_ignoreRobotsDirectives = true;
}
else
{
m_ignoreRobotsDirectives = false;
}
}
else if (nodeName == "mailaccount")
{
if (loadMailAccounts(pElem) == false)
{
cerr << _("Couldn't load mailaccount block") << endl;
}
}
}
}
}
catch (const std::exception& ex)
{
cerr << _("Couldn't parse configuration file") << ": "
<< ex.what() << endl;
success = false;
}
return success;
}
void Scenario::fromFile(const std::string &fileName, bool checkFiles) throw(xmlpp::exception, invalid_argument)
{
using namespace xmlpp;
using namespace Poco;
string xmlFile, fileType;
bool isArchive = false;
clear();
if (pDetector)
{
fileType = pDetector->typeOfFile(fileName);
}
if (fileType == "text/xml" || fileType == "application/xml")
{
xmlFile = fileName;
}
else if (!pDetector || fileType == "application/zip")
{
// attempt to unzip
FileInputStream input(fileName.c_str());
if (input.good())
{
// creating new temporary directory and extracting into it
sTempDir = TemporaryFile::tempName();
Zip::Decompress dec(input, sTempDir);
TemporaryFile::registerForDeletion(sTempDir);
// valid extraction
isArchive = false;
try
{
dec.decompressAllFiles();
isArchive = true;
}
catch (Poco::Exception)
{
if (!pDetector)
{
xmlFile = fileName;
}
else
{
throw xmlpp::exception("Bad file format");
}
}
if (isArchive)
{
Zip::Decompress::ZipMapping mapping = dec.mapping();
try
{
xmlFile = mapping.at("scenario.xml").makeAbsolute(sTempDir).toString();
}
catch(out_of_range &e)
{
throw xmlpp::exception("No scenario in file " + fileName);
}
}
}
else
{
throw xmlpp::exception("Unable to open the file " + fileName);
}
}
else
{
throw xmlpp::exception("Unrecognized file format");
}
ioConfig = IOConfig::detect(xmlFile, isArchive);
DomParser parser(xmlFile);
Document *document = parser.get_document();
Element *root = document->get_root_node();
if (root->get_name() != ioConfig.rootName())
{
throw xmlpp::exception("Bad document content type: " + ioConfig.rootName() + " expected");
}
// getting the user interface
try
{
Attribute *attr = root->get_attribute("interface");
if (attr)
{
uiInterface = stringToInterface(attr->get_value());
}
else
{
uiInterface = uiFull;
}
}
catch (invalid_argument)
{
throw xmlpp::exception("Bad user interface");
}
// now loading the different parts of the game
Node::NodeList node;
if (ioConfig.hasMetadata())
{
node = root->get_children("metadata");
if (!node.empty())
{
mMetadata.fromXML(*dynamic_cast<Element*>(node.front()));
}
}
node = root->get_children(ioConfig.plotName());
if (node.empty())
{
throw xmlpp::exception("Missing \"" + ioConfig.plotName() + "\" section");
}
else
{
tPlot.fromXML(ioConfig, *dynamic_cast<Element*>(node.front()), checkFiles);
}
node = root->get_children("notes");
if (node.empty())
{
throw xmlpp::exception("Missing \"notes\" section");
}
else
{
Element *elem = dynamic_cast<Element*>(node.front());
string mainText = "";
if (elem->has_child_text())
{
mainText = elem->get_child_text()->get_content();
}
nMain = Note("", mainText);
}
node = root->get_children(ioConfig.propertiesName());
if (node.empty())
{
throw xmlpp::exception("Missing \"" + ioConfig.propertiesName() + "\" section");
}
else
{
lProperties.fromXML(ioConfig, *dynamic_cast<Element*>(node.front()));
}
node = root->get_children("characters");
if (node.empty())
{
throw xmlpp::exception("Missing \"characters\" section");
}
else
{
lCharacters.fromXML(ioConfig, *dynamic_cast<Element*>(node.front()));
}
node = root->get_children("history");
if (node.empty())
{
throw xmlpp::exception("Missing \"history\" section");
}
else
{
tHistory.fromXML(ioConfig, *dynamic_cast<Element*>(node.front()), checkFiles);
}
node = root->get_children("music");
if (node.empty())
{
throw xmlpp::exception("Missing \"music\" section");
}
else
{
tMusic.fromXML(ioConfig, *dynamic_cast<Element*>(node.front()), checkFiles);
}
node = root->get_children("effects");
if (node.empty())
{
throw xmlpp::exception("Missing \"effects\" section");
}
else
{
tEffects.fromXML(ioConfig, *dynamic_cast<Element*>(node.front()), checkFiles);
}
}
ResponseParserInterface *OpenSearchParser::parse(SearchPluginProperties &properties,
bool extractSearchParams)
{
struct stat fileStat;
bool rssResponse = true, success = true;
if ((m_fileName.empty() == true) ||
(stat(m_fileName.c_str(), &fileStat) != 0) ||
(!S_ISREG(fileStat.st_mode)))
{
return NULL;
}
try
{
// Parse the configuration file
DomParser parser;
parser.set_substitute_entities(true);
parser.parse_file(m_fileName);
xmlpp::Document *pDocument = parser.get_document();
if (pDocument == NULL)
{
return NULL;
}
Node *pNode = pDocument->get_root_node();
Element *pRootElem = dynamic_cast<Element *>(pNode);
if (pRootElem == NULL)
{
return NULL;
}
// Check the top-level element is what we expect
// MozSearch is very much like OpenSearch Description
ustring rootNodeName = pRootElem->get_name();
if ((rootNodeName != "OpenSearchDescription") &&
(rootNodeName != "SearchPlugin"))
{
#ifdef DEBUG
cout << "OpenSearchParser::parse: wrong root node " << rootNodeName << endl;
#endif
return NULL;
}
// Go through the subnodes
const Node::NodeList childNodes = pRootElem->get_children();
if (childNodes.empty() == false)
{
for (Node::NodeList::const_iterator iter = childNodes.begin(); iter != childNodes.end(); ++iter)
{
Node *pChildNode = (*iter);
Element *pElem = dynamic_cast<Element*>(pChildNode);
if (pElem == NULL)
{
continue;
}
ustring nodeName(pChildNode->get_name());
ustring nodeContent(getNodeContent(pChildNode));
if (nodeName == "ShortName")
{
properties.m_name = nodeContent;
}
else if (nodeName == "Description")
{
properties.m_description = nodeContent;
}
else if (nodeName == "Url")
{
ustring url, type;
SearchPluginProperties::Response response = SearchPluginProperties::RSS_RESPONSE;
bool getMethod = true;
// Parse Query Syntax
Element::AttributeList attributes = pElem->get_attributes();
for (Element::AttributeList::const_iterator iter = attributes.begin();
iter != attributes.end(); ++iter)
{
Attribute *pAttr = (*iter);
if (pAttr != NULL)
{
ustring attrName = pAttr->get_name();
ustring attrContent = pAttr->get_value();
if (attrName == "template")
{
url = attrContent;
}
else if (attrName == "type")
{
type = attrContent;
}
else if (attrName == "method")
{
// GET is the default method
if (StringManip::toLowerCase(attrContent) != "get")
{
getMethod = false;
}
}
}
}
// Did we get the URL ?
if (url.empty() == true)
{
// It's probably provided as content, v1.0 style
url = nodeContent;
}
if (getMethod == true)
{
string::size_type startPos = 0, pos = url.find("?");
// Do we support that type ?
if (type == "application/atom+xml")
{
response = SearchPluginProperties::ATOM_RESPONSE;
rssResponse = false;
}
else if ((type.empty() == false) &&
(type != "application/rss+xml"))
{
response = SearchPluginProperties::UNKNOWN_RESPONSE;
#ifdef DEBUG
cout << "OpenSearchParser::parse: unsupported response type "
<< type << endl;
#endif
continue;
}
// Break the URL down into base and parameters
if (pos != string::npos)
{
string params(url.substr(pos + 1));
// URL
properties.m_baseUrl = url.substr(0, pos);
#ifdef DEBUG
cout << "OpenSearchParser::parse: URL is " << url << endl;
#endif
// Split this into the actual parameters
params += "&";
pos = params.find("&");
while (pos != string::npos)
{
string parameter(params.substr(startPos, pos - startPos));
string::size_type equalPos = parameter.find("=");
if (equalPos != string::npos)
{
string paramName(parameter.substr(0, equalPos));
string paramValue(parameter.substr(equalPos + 1));
SearchPluginProperties::Parameter param = SearchPluginProperties::UNKNOWN_PARAM;
if (paramValue == "{searchTerms}")
{
param = SearchPluginProperties::SEARCH_TERMS_PARAM;
}
else if (paramValue == "{count}")
{
param = SearchPluginProperties::COUNT_PARAM;
}
else if (paramValue == "{startIndex}")
{
param = SearchPluginProperties::START_INDEX_PARAM;
}
else if (paramValue == "{startPage}")
{
param = SearchPluginProperties::START_PAGE_PARAM;
}
else if (paramValue == "{language}")
{
param = SearchPluginProperties::LANGUAGE_PARAM;
}
else if (paramValue == "{outputEncoding}")
{
param = SearchPluginProperties::OUTPUT_ENCODING_PARAM;
}
else if (paramValue == "{inputEncoding}")
{
param = SearchPluginProperties::INPUT_ENCODING_PARAM;
}
if (param != SearchPluginProperties::UNKNOWN_PARAM)
{
properties.m_parameters[param] = paramName;
}
else
{
// Append to the remainder
if (properties.m_parametersRemainder.empty() == false)
{
properties.m_parametersRemainder += "&";
}
properties.m_parametersRemainder += paramName;
properties.m_parametersRemainder += "=";
properties.m_parametersRemainder += paramValue;
}
}
// Next
startPos = pos + 1;
pos = params.find_first_of("&", startPos);
}
}
// Method
properties.m_method = SearchPluginProperties::GET_METHOD;
// Output type
properties.m_outputType = type;
// Response
properties.m_response = response;
}
// We ignore Param as we only support GET
}
else if (nodeName == "Tags")
{
// This is supposed to be a space-delimited list, but use the whole thing as channel
properties.m_channel = nodeContent;
}
else if (nodeName == "LongName")
{
properties.m_longName = nodeContent;
}
else if (nodeName == "Language")
{
properties.m_languages.insert(nodeContent);
}
else if (nodeName == "OutputEncoding")
{
properties.m_outputEncodings.insert(nodeContent);
}
else if (nodeName == "InputEncoding")
{
properties.m_inputEncodings.insert(nodeContent);
}
}
}
}
catch (const std::exception& ex)
{
#ifdef DEBUG
cout << "OpenSearchParser::parse: caught exception: " << ex.what() << endl;
#endif
success = false;
}
if (success == false)
{
return NULL;
}
// Scrolling
properties.m_nextIncrement = 1;
properties.m_nextBase = 1;
if (properties.m_parameters.find(SearchPluginProperties::START_PAGE_PARAM) != properties.m_parameters.end())
{
properties.m_scrolling = SearchPluginProperties::PER_PAGE;
}
else
{
properties.m_scrolling = SearchPluginProperties::PER_INDEX;
}
return new OpenSearchResponseParser(rssResponse);
}
void Scenario::fromFile(const std::string &fileName) throw(xmlpp::exception, invalid_argument, overflow_error)
{
using namespace xmlpp;
clear();
DomParser parser(fileName);
Document *document = parser.get_document();
Element *root = document->get_root_node();
if (root->get_name()!="game")
{
throw xmlpp::exception("Bad document content type: game expected");
}
// getting the user interface
try
{
Attribute *attr = root->get_attribute("interface");
if (attr != NULL)
{
uiInterface = stringToInterface(attr->get_value());
}
else
{
uiInterface = uiFull;
}
}
catch (invalid_argument)
{
throw xmlpp::exception("Bad user interface");
}
// now loading the different parts of the game
Node::NodeList node = root->get_children("scenario");
if (!node.empty())
{
tScenario.fromXML(*dynamic_cast<Element*>(node.front()));
}
node = root->get_children("notes");
if (!node.empty())
{
Element *elem = dynamic_cast<Element*>(node.front());
if (elem->has_child_text())
{
sNotes = elem->get_child_text()->get_content();
}
else
{
sNotes = "";
}
}
node = root->get_children("skills");
if (!node.empty())
{
lSkills.fromXML(*dynamic_cast<Element*>(node.front()));
}
node = root->get_children("characters");
if (!node.empty())
{
lCharacters.fromXML(*dynamic_cast<Element*>(node.front()));
}
node = root->get_children("history");
if (!node.empty())
{
tHistory.fromXML(*dynamic_cast<Element*>(node.front()));
}
node = root->get_children("music");
if (!node.empty())
{
tMusic.fromXML(*dynamic_cast<Element*>(node.front()));
}
node = root->get_children("effects");
if (!node.empty())
{
tEffects.fromXML(*dynamic_cast<Element*>(node.front()),true);
}
}