kopete/protocols/jabber/libiris/iris/xmpp-im/xmpp_xdata.cpp

   1 /*
   2  * xmpp_xdata.cpp - a class for jabber:x:data forms
   3  * Copyright (C) 2003-2004  Michail Pishchagin
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18  *
  19  */
  20
  21 #include "xmpp_xdata.h"
  22 #include "xmpp_xmlcommon.h"
  23 #include "xmpp_jid.h"
  24
  25 #include <QList>
  26 #include <QSharedDataPointer>
  27
  28 using namespace XMPP;
  29 using namespace XMLHelper;
  30
  31 // TODO: report, item
  32
  33 //----------------------------------------------------------------------------
  34 // XData::Field
  35 //----------------------------------------------------------------------------
  36 XData::Field::Field()
  37 {
  38 }
  39
  40 XData::Field::~Field()
  41 {
  42 }
  43
  44 QString XData::Field::desc() const
  45 {
  46         return _desc;
  47 }
  48
  49 void XData::Field::setDesc(const QString &d)
  50 {
  51         _desc = d;
  52 }
  53
  54 XData::Field::OptionList XData::Field::options() const
  55 {
  56         return _options;
  57 }
  58
  59 void XData::Field::setOptions(XData::Field::OptionList o)
  60 {
  61         _options = o;
  62 }
  63
  64 bool XData::Field::required() const
  65 {
  66         return _required;
  67 }
  68
  69 void XData::Field::setRequired(bool r)
  70 {
  71         _required = r;
  72 }
  73
  74 QString XData::Field::label() const
  75 {
  76         return _label;
  77 }
  78
  79 void XData::Field::setLabel(const QString &l)
  80 {
  81         _label = l;
  82 }
  83
  84 QString XData::Field::var() const
  85 {
  86         return _var;
  87 }
  88
  89 void XData::Field::setVar(const QString &v)
  90 {
  91         _var = v;
  92 }
  93
  94 QStringList XData::Field::value() const
  95 {
  96         return _value;
  97 }
  98
  99 void XData::Field::setValue(const QStringList &v)
 100 {
 101         _value = v;
 102 }
 103
 104 XData::Field::Type XData::Field::type() const
 105 {
 106         return _type;
 107 }
 108
 109 void XData::Field::setType(XData::Field::Type t)
 110 {
 111         _type = t;
 112 }
 113
 114 bool XData::Field::isValid() const
 115 {
 116         if ( _required && _value.isEmpty() )
 117                 return false;
 118
 119         if ( _type == Field_Hidden || _type == Field_Fixed) {
 120                 return true;
 121         }
 122         if ( _type == Field_Boolean ) {
 123                 if ( _value.count() != 1 )
 124                         return false;
 125
 126                 QString str = _value.first();
 127                 if ( str == "0" || str == "1" || str == "true" || str == "false" || str == "yes" || str == "no" )
 128                         return true;
 129         }
 130         if ( _type == Field_TextSingle || _type == Field_TextPrivate ) {
 131                 if ( _value.count() == 1 )
 132                         return true;
 133         }
 134         if ( _type == Field_TextMulti ) {
 135                 //no particular test. empty/required case already caught (see above)
 136                 return true;
 137         }
 138         if ( _type == Field_ListSingle || _type == Field_ListMulti ) {
 139                 //no particular test. empty/required case already caught (see above)
 140                 return true;
 141         }
 142         if ( _type == Field_JidSingle ) {
 143                 if ( _value.count() != 1 )
 144                         return false;
 145
 146                 Jid j( _value.first() );
 147                 return j.isValid();
 148         }
 149         if ( _type == Field_JidMulti ) {
 150                 QStringList::ConstIterator it = _value.begin();
 151                 bool allValid = true;
 152                 for ( ; it != _value.end(); ++it) {
 153                         Jid j(*it);
 154                         if ( !j.isValid() ) {
 155                                 allValid = false;
 156                                 break;
 157                         }
 158                 }
 159                 return allValid;
 160         }
 161
 162         return false;
 163 }
 164
 165 void XData::Field::fromXml(const QDomElement &e)
 166 {
 167         if ( e.tagName() != "field" )
 168                 return;
 169
 170         _var = e.attribute("var");
 171         _label = e.attribute("label");
 172
 173         QString type = e.attribute("type");
 174         if ( type == "boolean" )
 175                 _type = Field_Boolean;
 176         else if ( type == "fixed" )
 177                 _type = Field_Fixed;
 178         else if ( type == "hidden" )
 179                 _type = Field_Hidden;
 180         else if ( type == "jid-multi" )
 181                 _type = Field_JidMulti;
 182         else if ( type == "jid-single" )
 183                 _type = Field_JidSingle;
 184         else if ( type == "list-multi" )
 185                 _type = Field_ListMulti;
 186         else if ( type == "list-single" )
 187                 _type = Field_ListSingle;
 188         else if ( type == "text-multi" )
 189                 _type = Field_TextMulti;
 190         else if ( type == "text-private" )
 191                 _type = Field_TextPrivate;
 192         else
 193                 _type = Field_TextSingle;
 194
 195         _required = false;
 196         _desc     = QString();
 197         _options.clear();
 198         _value.clear();
 199
 200         QDomNode n = e.firstChild();
 201         for ( ; !n.isNull(); n = n.nextSibling() ) {
 202                 QDomElement i = n.toElement();
 203                 if ( i.isNull() )
 204                         continue;
 205
 206                 QString tag = i.tagName();
 207                 if ( tag == "required" )
 208                         _required = true;
 209                 else if ( tag == "desc" )
 210                         _desc = i.text().trimmed();
 211                 else if ( tag == "option" ) {
 212                         Option o;
 213                         bool found;
 214                         o.label = i.attribute("label");
 215
 216                         QDomElement e = findSubTag( i, "value", &found );
 217                         o.value = ( found ? e.text() : QString("") );
 218                         _options.append(o);
 219                 }
 220                 else if ( tag == "value" ) {
 221                         _value.append(i.text());
 222                 }
 223         }
 224 }
 225
 226 QDomElement XData::Field::toXml(QDomDocument *doc, bool submitForm) const
 227 {
 228         QDomElement f = doc->createElement("field");
 229
 230         // setting attributes...
 231         if ( !_var.isEmpty() )
 232                 f.setAttribute("var", _var);
 233         if ( !submitForm && !_label.isEmpty() )
 234                 f.setAttribute("label", _label);
 235
 236         // now we're gonna get the 'type'
 237         QString type = "text-single";
 238         if ( _type == Field_Boolean )
 239                 type = "boolean";
 240         else if ( _type == Field_Fixed )
 241                 type = "fixed";
 242         else if ( _type == Field_Hidden )
 243                 type = "hidden";
 244         else if ( _type == Field_JidMulti )
 245                 type = "jid-multi";
 246         else if ( _type == Field_JidSingle )
 247                 type = "jid-single";
 248         else if ( _type == Field_ListMulti )
 249                 type = "list-multi";
 250         else if ( _type == Field_ListSingle )
 251                 type = "list-single";
 252         else if ( _type == Field_TextMulti )
 253                 type = "text-multi";
 254         else if ( _type == Field_TextPrivate )
 255                 type = "text-private";
 256
 257         f.setAttribute("type", type);
 258
 259         // now, setting nested tags...
 260         if ( !submitForm && _required )
 261                 f.appendChild( emptyTag(doc, "required") );
 262
 263         if ( !submitForm && !_desc.isEmpty() )
 264                 f.appendChild( textTag(doc, "desc", _desc) );
 265
 266         if ( !submitForm && !_options.isEmpty() ) {
 267                 OptionList::ConstIterator it = _options.begin();
 268                 for ( ; it != _options.end(); ++it) {
 269                         QDomElement o = doc->createElement("option");
 270                         o.appendChild(textTag(doc, "value", (*it).value));
 271                         if ( !(*it).label.isEmpty() )
 272                                 o.setAttribute("label", (*it).label);
 273                         f.appendChild(o);
 274                 }
 275         }
 276
 277         if ( !_value.isEmpty() ) {
 278                 QStringList::ConstIterator it = _value.begin();
 279                 for ( ; it != _value.end(); ++it)
 280                         f.appendChild( textTag(doc, "value", *it) );
 281         }
 282
 283         return f;
 284 }
 285
 286 //----------------------------------------------------------------------------
 287 // XData
 288 //----------------------------------------------------------------------------
 289
 290 XData::XData()
 291 {
 292         d = new Private;
 293 }
 294
 295 QString XData::title() const
 296 {
 297         return d->title;
 298 }
 299
 300 void XData::setTitle(const QString &t)
 301 {
 302         d->title = t;
 303 }
 304
 305 QString XData::instructions() const
 306 {
 307         return d->instructions;
 308 }
 309
 310 void XData::setInstructions(const QString &i)
 311 {
 312         d->instructions = i;
 313 }
 314
 315 XData::Type XData::type() const
 316 {
 317         return d->type;
 318 }
 319
 320 void XData::setType(Type t)
 321 {
 322         d->type = t;
 323 }
 324
 325 XData::FieldList XData::fields() const
 326 {
 327         return d->fields;
 328 }
 329
 330 void XData::setFields(const FieldList &f)
 331 {
 332         d->fields = f;
 333 }
 334
 335 void XData::fromXml(const QDomElement &e)
 336 {
 337         if ( (e.attribute("xmlns") != "jabber:x:data") && (e.namespaceURI() != "jabber:x:data") )
 338                 return;
 339
 340         QString type = e.attribute("type");
 341         if ( type == "result" )
 342                 d->type = Data_Result;
 343         else if ( type == "submit" )
 344                 d->type = Data_Submit;
 345         else if ( type == "cancel" )
 346                 d->type = Data_Cancel;
 347         else
 348                 d->type = Data_Form;
 349
 350         d->title        = subTagText(e, "title");
 351         d->instructions = subTagText(e, "instructions");
 352
 353         d->fields.clear();
 354
 355         QDomNode n = e.firstChild();
 356         for ( ; !n.isNull(); n = n.nextSibling() ) {
 357                 QDomElement i = n.toElement();
 358                 if ( i.isNull() )
 359                         continue;
 360
 361                 if ( i.tagName() == "field" ) {
 362                         Field f;
 363                         f.fromXml(i);
 364                         d->fields.append(f);
 365                 }
 366                 else if ( i.tagName() == "reported" ) {
 367                         d->report.clear();
 368                         d->reportItems.clear();
 369
 370                         QDomNode nn = i.firstChild();
 371                         for ( ; !nn.isNull(); nn = nn.nextSibling() ) {
 372                                 QDomElement ii = nn.toElement();
 373                                 if ( ii.isNull() )
 374                                         continue;
 375
 376                                 if ( ii.tagName() == "field" ) {
 377                                         d->report.append( ReportField( ii.attribute("label"), ii.attribute("var") ) );
 378                                 }
 379                         }
 380                 }
 381                 else if ( i.tagName() == "item" ) {
 382                         ReportItem item;
 383
 384                         QDomNode nn = i.firstChild();
 385                         for ( ; !nn.isNull(); nn = nn.nextSibling() ) {
 386                                 QDomElement ii = nn.toElement();
 387                                 if ( ii.isNull() )
 388                                         continue;
 389
 390                                 if ( ii.tagName() == "field" ) {
 391                                         QString name = ii.attribute("var");
 392                                         QString value;
 393
 394                                         bool found;
 395                                         QDomElement e = findSubTag( ii, "value", &found );
 396                                         if ( found )
 397                                                 value = e.text();
 398
 399                                         item[name] = value;
 400                                 }
 401                         }
 402
 403                         d->reportItems.append( item );
 404                 }
 405         }
 406 }
 407
 408 QDomElement XData::toXml(QDomDocument *doc, bool submitForm) const
 409 {
 410         QDomElement x = doc->createElementNS("jabber:x:data", "x");
 411         x.setAttribute("xmlns", "jabber:x:data");
 412
 413         QString type = "form";
 414         if ( d->type == Data_Result )
 415                 type = "result";
 416         else if ( d->type == Data_Submit )
 417                 type = "submit";
 418         else if ( d->type == Data_Cancel )
 419                 type = "cancel";
 420
 421         x.setAttribute("type", type);
 422
 423         if ( !submitForm && !d->title.isEmpty() )
 424                 x.appendChild( textTag(doc, "title", d->title) );
 425         if ( !submitForm && !d->instructions.isEmpty() )
 426                 x.appendChild( textTag(doc, "instructions", d->instructions) );
 427
 428         if ( !d->fields.isEmpty() ) {
 429                 FieldList::ConstIterator it = d->fields.begin();
 430                 for ( ; it != d->fields.end(); ++it) {
 431                         Field f = *it;
 432                         if ( !(submitForm && f.var().isEmpty()) )
 433                                 x.appendChild( f.toXml(doc, submitForm) );
 434                 }
 435         }
 436
 437         return x;
 438 }
 439
 440 const QList<XData::ReportField> &XData::report() const
 441 {
 442         return d->report;
 443 }
 444
 445 const QList<XData::ReportItem> &XData::reportItems() const
 446 {
 447         return d->reportItems;
 448 }
 449
 450 bool XData::isValid() const
 451 {
 452         foreach(Field f, d->fields) {
 453                 if (!f.isValid())
 454                         return false;
 455         }
 456         return true;
 457 }