DomainPluginTypes.h

Go to the documentation of this file.

#ifndef DOMAINPLUGINTYPES_H_
#define DOMAINPLUGINTYPES_H_

#include <stlrt/atypes.h>

#include <pluginconfig.h>

struct PLUGINTOOLKIT_DECL DTIOTypeAbstract {
  Str log;
};

struct PLUGINTOOLKIT_DECL DTNameServer {
  Str hostName; 
  Str ipAddr;   

  DTNameServer () {};

  DTNameServer (const Str & aHostName, const Str & aIPAddr)
    : hostName(aHostName), ipAddr(aIPAddr) {}

  DTNameServer (const Str & aHostName)
    : hostName(aHostName), ipAddr(Str()) {}
};

class PLUGINTOOLKIT_DECL DTNameServers {
  list<DTNameServer> nses;
  mutable list<DTNameServer>::const_iterator iCur;
public:
  DTNameServers()
    { iCur = nses.end(); };

  void add(const Str & aHostName, const Str & aIPAddr )
    { nses.push_back( DTNameServer(aHostName, aIPAddr) ); };

  void add(const Str & aHostName )
    { nses.push_back( DTNameServer( aHostName ) ); };

  void clear ()
    { nses.clear(); };

  bool next() const {
    if ( nses.empty() ) return false;

    if ( iCur == nses.end() ) {
      iCur = nses.begin();
      return true;
    } else
      return (nses.end() != ++iCur);
  }

  const DTNameServer & get() const {
    // TODO: Possible SIGFAULT if call get on empty list (get == end)
    return *iCur;
  }

  DTNameServers &operator= (const DTNameServers& t) {
    if(this==&t) return *this;
    nses = t.nses;
    iCur = nses.end();
    return *this;
  }

  DTNameServers(const DTNameServers& t) {
    if(this!=&t) {
      nses = t.nses;
      iCur = nses.end();
    }
  }

  friend class DTNameServersSerializer;
};

struct PLUGINTOOLKIT_DECL DTPhone {
  Str cc;
  Str area;
  Str number;
  Str ext;
  DTPhone() : cc(), area(), number(), ext() {}
  DTPhone(const Str & aCc, const Str & aArea, const Str & aNumber, const Str & aExt)
    : cc(aCc), area(aArea), number(aNumber), ext(aExt) {}

  Str toE164() const {
    if (cc.length() == 0 || number.length() == 0)
      return Str("");

    Str e164= Str("+") << cc << "." << area << number;
    if ((e164.length() + ext.length()) < 17) {
      e164 << ext;
    } else {
      // "WARNING: E.164 phone number max length 15 digits. Phone extension will be deleted from number";
    }
    return e164;
  }
};


class PLUGINTOOLKIT_DECL DTExtData {
  map<Str, Str> pdata;
  mutable map<Str, Str>::const_iterator iCur;
public:
  DTExtData() : iCur( pdata.end() ) {};

  DTExtData(const map<Str, Str> & m) : pdata(m) { iCur = pdata.end(); };

  const Str operator [] (const Str &key) const {
    map<Str, Str>::const_iterator it = pdata.find(key);
    return ( pdata.end() != it ) ? it->second : Str();
  }

  bool isExist(const Str &key) {
    return pdata.find(key) != pdata.end();
  };

  bool next() const {
    if ( pdata.empty() ) return false;

    if ( iCur == pdata.end() ) {
      iCur = pdata.begin();
      return true;
    } else{
      return (pdata.end() != ++iCur);
    }
  };

  const Str & getKey() const {
    return iCur->first;
  };

  const Str & getValue() const {
    return iCur->second;
  };

  void add(const Str& key, const Str& val) {
    pdata.insert( pair<Str, Str> (key, val) );
    iCur = pdata.end();
  };

  void set(const Str& key, const Str& val) {
    pdata[key] = val;
    iCur = pdata.end();
  };



  bool exists(const Str &key) const {
    map<Str, Str>::const_iterator it = pdata.find(key);
    return ( pdata.end() == it ) ? false : true;
  }

  DTExtData &operator= (const DTExtData& t) {
    if(this==&t) return *this;
    pdata = t.pdata;
    iCur = pdata.end();
    return *this;
  }

  DTExtData(const DTExtData& t) {
    if(this!=&t) {
      pdata = t.pdata;
      iCur = pdata.end();
    }
  }

  friend class DTExtDataSerializer;
};

struct PLUGINTOOLKIT_DECL DTContact {
  Int cID; /* Internal contact ID (Now UserID in BM) */
  Str orgName;
  Str fName; Str mName; Str lName;
  Str eMail;
  Str address1; Str address2;
  Str city; Str state; Str stateName; Str zip; Str country;
  DTPhone phone; DTPhone fax;
  DTExtData extData;
  Str handleID;
  Str birthday;
  DTContact() {}
};

struct PLUGINTOOLKIT_DECL DTContacts {
  DTContact owner;
  DTContact admin;
  DTContact bill;
  DTContact tech;
  DTContacts() {}
};

enum DTDomainOpType {
  TOP_REGISTER  = 1, 
  TOP_TRANSFER  = 2, 
  TOP_RENEW     = 3, 
  TOP_TERMINATE = 4, 
  TOP_RESOLVE   = 5  
};

enum DTDomainChkStatus {
  DOMAIN_AVAIL    = 1, 
  DOMAIN_NOTAVAIL = 2, 
  DOMAIN_ERROR    = 3  
};

enum DTDomainLock {
  DOMAIN_LOCK_SET    = 1, 
  DOMAIN_LOCK_NOTSET = 2  
};

enum DTDomainWhoisPrivacy {
  DOMAIN_WHOIS_PRIVACY_SET    = 1,
  DOMAIN_WHOIS_PRIVACY_NOTSET = 2 
};

enum DTDomainOpStatus {
  OP_PROCESSING       = 1, 
  OP_OK               = 2, 
  OP_ERROR            = 3, 
  OP_WAITING_CALLBACK = 4 
};

struct PLUGINTOOLKIT_DECL DTDomainChk {
  DTDomainChkStatus status; 
  Str msg; 
  DTDomainChk() : status(DOMAIN_ERROR), msg( Str() ) {};
  DTDomainChk(const DTDomainChkStatus aStatus, const Str &aMsg)
    : status( aStatus ), msg( aMsg ) {};
};

struct PLUGINTOOLKIT_DECL DTDomainTransferChk : public DTDomainChk {
  bool isRenewRequired;
  DTDomainTransferChk()
    : DTDomainChk( DOMAIN_ERROR, Str() ), isRenewRequired(false) {};

  DTDomainTransferChk(const DTDomainChkStatus aStatus, const Str &aMsg)
    : DTDomainChk(aStatus , aMsg), isRenewRequired(false) {};

  DTDomainTransferChk(const DTDomainChkStatus aStatus, const bool aIsRenewRequired, const Str &aMsg)
    : DTDomainChk(aStatus , aMsg), isRenewRequired(aIsRenewRequired) {};
};

struct PLUGINTOOLKIT_DECL DTDomain {
  Str sld;
  Str tld;

  Str domainName() const { return Str() << sld << "." << tld; };

  DTDomain(const Str & aSld, const Str & aTld)
    : sld(aSld), tld(aTld) {};
  DTDomain() : sld(Str()), tld(Str()) {};
};


struct PLUGINTOOLKIT_DECL DTDomainTransfer : public DTDomain {
  Str transferKey; 
  DTDomainTransfer() : DTDomain(), transferKey(Str()) {};

  DTDomainTransfer(const Str & aSld, const Str & aTld) :
    DTDomain(aSld, aTld), transferKey( Str() ) {};

  DTDomainTransfer(const Str & aSld, const Str & aTld, const Str & aTransferKey) :
    DTDomain(aSld, aTld), transferKey(aTransferKey) {};
};

struct PLUGINTOOLKIT_DECL DTInDomainData : public DTDomain {
  DTExtData extData;
  DTInDomainData() {};
};

struct PLUGINTOOLKIT_DECL DTInOperationDomain : public DTInDomainData {
  DTInOperationDomain() {};
};


struct PLUGINTOOLKIT_DECL DTOutGeneral : DTIOTypeAbstract {
  Str msg;
  DTOutGeneral() : msg( Str() ) {}
};

struct PLUGINTOOLKIT_DECL DTOutOperationDomain : public DTOutGeneral {
  DTDomainOpStatus opStatus; 

  DTExtData extData; 

  DTOutOperationDomain() : opStatus(OP_ERROR) {};
};

struct PLUGINTOOLKIT_DECL DTInSetLock : public DTInOperationDomain {
  DTDomainLock value;
  DTInSetLock() {};
};

struct PLUGINTOOLKIT_DECL DTOutSetLock : public DTOutOperationDomain {
  DTOutSetLock() {};
};

struct PLUGINTOOLKIT_DECL DTInSetWhoisPrivacy : public DTInOperationDomain {
  DTDomainWhoisPrivacy value;
  DTInSetWhoisPrivacy() {};
};

struct PLUGINTOOLKIT_DECL DTOutSetWhoisPrivacy : public DTOutOperationDomain {
  DTOutSetWhoisPrivacy() {};
};

enum DTExtDataItemStatus {
  EDIS_OK = 1,     
  EDIS_FAILED = 2, 
  EDIS_NEEDED = 3, 
  EDIS_SAVENOTNEED = 4
};

struct PLUGINTOOLKIT_DECL DTTypedExtDataItem {

  Str paramID;   
  Str type;      
  Str title;     
  Str descr;     
  Str defValue;  
  bool required; 
  DTExtDataItemStatus status; 
  Str msg;
  DTTypedExtDataItem() {};
  DTTypedExtDataItem(
    const Str& aKey,
    const Str& aType,
    const Str& aTitle,
    const Str& aDescr,
    const Str& aDefValue,
    const bool aRequired, 
    const DTExtDataItemStatus aStatus,
    const Str & aMsg = ""
    )
      : paramID(aKey), type(aType), title(aTitle), descr(aDescr),
        defValue(aDefValue), required(aRequired), status(aStatus), msg( aMsg ) {};
};

/* ------------------------ Types by API methods ---------------------------- */


class DTInCheckAvailability : public DTIOTypeAbstract {
  list<DTDomain> listDomainName;
  mutable list<DTDomain>::const_iterator iCur;
public:
  DTInCheckAvailability()
    { iCur = listDomainName.begin(); };


  void add(const Str & aSld, const Str & aTld)
    { listDomainName.push_back( DTDomain(aSld, aTld) ); };
  
  void clear ()
    { listDomainName.clear(); };


  bool next() const {
    if ( listDomainName.empty() ) return false;

    if ( iCur == listDomainName.end() ) {
      iCur = listDomainName.begin();
      return true;
    } else
      return (listDomainName.end() != ++iCur);
  };

  const DTDomain & get() const {
    // TODO: Possible SIGFAULT if call get on empty list (get == end)
    return *iCur;
  };

  DTInCheckAvailability &operator= (const DTInCheckAvailability& t) {
    if(this==&t) return *this;
    listDomainName = t.listDomainName;
    iCur = listDomainName.end();
    return *this;
  }

  DTInCheckAvailability(const DTInCheckAvailability& t):DTIOTypeAbstract() {
    if(this!=&t) {
      listDomainName = t.listDomainName;
      iCur = listDomainName.end();
    }
  }

  friend class DTInCheckAvailabilitySerializer;
};


class DTOutCheckAvailability : public DTIOTypeAbstract {
  map<Str, DTDomainChk> domainNameSt;
  mutable map<Str, DTDomainChk>::const_iterator iCur;
public:
  DTOutCheckAvailability() : iCur( domainNameSt.end() ) {};
  const DTDomainChk operator [] (const Str& domainName) {
    return ( domainNameSt.end() != domainNameSt.find(domainName) )
      ? domainNameSt[domainName] : DTDomainChk();
  }


  void add(const Str& domainName, const DTDomainChkStatus status, const Str &msg) {
    domainNameSt.insert( pair<Str, DTDomainChk> (domainName, DTDomainChk(status, msg) ) );
  }
  

  void add(const Str& domainName, const DTDomainChkStatus status) {
    domainNameSt.insert(
      pair<Str, DTDomainChk> (domainName, DTDomainChk(status, Str()) ) );
  }

  bool next() const {
    if ( domainNameSt.empty() ) return false;

    if ( iCur == domainNameSt.end() ) {
      iCur = domainNameSt.begin();
      return true;
    } else
      return (domainNameSt.end() != ++iCur);
  };

  const Str & getName() const {
    return iCur->first;
  }

  const DTDomainChk & getStatus() const {
    return iCur->second;
  };

  const DTDomainChk & get() const {
    return iCur->second;
  };

  DTOutCheckAvailability &operator= (const DTOutCheckAvailability& t) {
    if(this==&t) return *this;
    domainNameSt = t.domainNameSt;
    iCur = domainNameSt.end();
    return *this;
  }

  DTOutCheckAvailability(const DTOutCheckAvailability& t) : DTIOTypeAbstract(){
    if(this!=&t) {
      domainNameSt = t.domainNameSt;
      iCur = domainNameSt.end();
    }
  }
  friend class DTOutCheckAvailabilitySerializer;
};


class DTInCheckTransfer : public DTIOTypeAbstract {
  list<DTDomainTransfer> listDomainName;
  mutable list<DTDomainTransfer>::const_iterator iCur;
public:
  DTInCheckTransfer()
    { iCur = listDomainName.begin(); };


  void add(const Str & sld, const Str & tld)
    { listDomainName.push_back( DTDomainTransfer (sld, tld) ); };


  void add(const Str & sld, const Str & tld, const Str & transferKey)
    { listDomainName.push_back( DTDomainTransfer (sld, tld, transferKey) ); };

  void clear ()
    { listDomainName.clear(); };

  bool next() const {
    if ( listDomainName.empty() ) return false;

    if ( iCur == listDomainName.end() ) {
      iCur = listDomainName.begin();
      return true;
    } else {
      return (listDomainName.end() != ++iCur);
    }
  };

  const DTDomainTransfer & get() const {
    return *iCur;
  };

  DTInCheckTransfer &operator= (const DTInCheckTransfer& t) {
    if(this==&t) return *this;
    listDomainName = t.listDomainName;
    iCur = listDomainName.end();
    return *this;
  }

  DTInCheckTransfer(const DTInCheckTransfer& t) : DTIOTypeAbstract(){
    if(this!=&t) {
      listDomainName = t.listDomainName;
      iCur = listDomainName.end();
    }
  }


  friend class DTInCheckTransferSerializer;
};

/* Output struct PLUGINTOOLKIT_DECL for checkTransfer ------------------------------------------ */
class DTOutCheckTransfer : public DTIOTypeAbstract {
  map<Str, DTDomainTransferChk> domainNameSt;
  mutable map<Str, DTDomainTransferChk>::const_iterator iCur;
public:
  DTOutCheckTransfer() : iCur( domainNameSt.end() ) {};
  const DTDomainTransferChk operator [] (const Str& domainName) {
    return ( domainNameSt.end() != domainNameSt.find(domainName) )
      ? domainNameSt[domainName] : DTDomainTransferChk();
  }


  void add(const Str& domainName, const DTDomainChkStatus status, const Str &msg) {
    domainNameSt.insert( pair<Str, DTDomainTransferChk> (domainName, DTDomainTransferChk(status, msg) ) );
  }


  void add(const Str& domainName, const DTDomainChkStatus status) {
    add( domainName, status, Str() );
  }


  void add(const Str& domainName, const DTDomainChkStatus status, const bool isRenewRequired, const Str &msg) {
    domainNameSt.insert(
      pair<Str, DTDomainTransferChk> (domainName, DTDomainTransferChk(status, isRenewRequired, msg) ) );
  }


  void add(const Str& domainName, const DTDomainChkStatus status, const bool isRenewRequired) {
    add( domainName, status, isRenewRequired, Str() );
  }

  bool next() const {
    if ( domainNameSt.empty() ) return false;

    if ( iCur == domainNameSt.end() ) {
      iCur = domainNameSt.begin();
      return true;
    } else
      return (domainNameSt.end() != ++iCur);
  };

  const Str & getName() const {
    return iCur->first;
  }

  const DTDomainTransferChk & getStatus() const {
    return iCur->second;
  };

  const DTDomainChk & get() const {
    return iCur->second;
  };

  DTOutCheckTransfer &operator= (const DTOutCheckTransfer& t) {
    if(this==&t) return *this;
    domainNameSt = t.domainNameSt;
    iCur = domainNameSt.end();
    return *this;
  }

  DTOutCheckTransfer(const DTOutCheckTransfer& t) : DTIOTypeAbstract() {
    if(this!=&t) {
      domainNameSt = t.domainNameSt;
      iCur = domainNameSt.end();
    }
  }

  friend class DTOutCheckTransferSerializer;
};

struct PLUGINTOOLKIT_DECL DTInRegisterDomain : public DTInOperationDomain {
  Int period;                // Domain registration period
  DTNameServers nameServers;
  DTContacts contacts;
  DTInRegisterDomain () {};
};

struct PLUGINTOOLKIT_DECL DTOutRegisterDomain : public DTOutOperationDomain {
  Str expDate;                   // format 'YYYY-MM-DD HH:MM:SS'
  DTOutRegisterDomain() : expDate( Str() ) {}
};

struct PLUGINTOOLKIT_DECL DTInTransferDomain : public DTInOperationDomain {
  Str transferKey;
  Int period;                // transfer includes renewal period
  DTNameServers nameServers;
  DTContacts contacts;
  DTInTransferDomain () {};
};

struct PLUGINTOOLKIT_DECL DTOutTransferDomain : public DTOutOperationDomain {
  Str expDate;                   // format 'YYYY-MM-DD HH:MM:SS'
  DTOutTransferDomain() : expDate( Str() ) {}
};

struct PLUGINTOOLKIT_DECL DTInRenewDomain : public DTInOperationDomain {
  Int period;     
  DTInRenewDomain () {};
};

struct PLUGINTOOLKIT_DECL DTOutRenewDomain : public DTOutOperationDomain {
  Str expDate;                   
  DTOutRenewDomain() : expDate( Str() ) {}
};

struct PLUGINTOOLKIT_DECL DTInTerminateDomain : public DTInOperationDomain {
  DTInTerminateDomain () {};
};

struct PLUGINTOOLKIT_DECL DTOutTerminateDomain : public DTOutOperationDomain {
  DTOutTerminateDomain() {};
};

struct PLUGINTOOLKIT_DECL DTInGetDomainStatus : public DTInOperationDomain {
  DTDomainOpType opType; 
  DTInGetDomainStatus() {};
};

struct PLUGINTOOLKIT_DECL DTOutGetDomainStatus : public DTOutOperationDomain {
  Str expDate;                   
  DTOutGetDomainStatus(): expDate( Str() ) {};
};

struct PLUGINTOOLKIT_DECL DTInRegisterContacts : public DTInOperationDomain {
  DTContacts contacts;
  DTInRegisterContacts() {};
};

struct PLUGINTOOLKIT_DECL DTOutRegisterContacts : public DTOutOperationDomain {
  DTOutRegisterContacts() {};
};

struct PLUGINTOOLKIT_DECL DTInGetContactsStatus : public DTInOperationDomain {
  DTContacts contacts;
  DTInGetContactsStatus() {};
};

struct PLUGINTOOLKIT_DECL DTOutGetContactsStatus : public DTOutOperationDomain {
  DTOutGetContactsStatus() {};
};

struct PLUGINTOOLKIT_DECL DTInRegisterNameServers : public DTInOperationDomain {
  DTNameServers nameServers;
  DTInRegisterNameServers() {};
};

struct PLUGINTOOLKIT_DECL DTOutRegisterNameServers : public DTOutOperationDomain {
  DTOutRegisterNameServers() {};
};

struct PLUGINTOOLKIT_DECL DTInGetNameServersStatus : public DTInOperationDomain {
  DTNameServers nameServers;
  DTInGetNameServersStatus() {};
};

struct PLUGINTOOLKIT_DECL DTOutGetNameServersStatus : public DTOutOperationDomain {
  DTOutGetNameServersStatus() {};
};

struct PLUGINTOOLKIT_DECL DTInGetDomainDetails : public DTInDomainData {
  DTInGetDomainDetails() {};
};

struct PLUGINTOOLKIT_DECL DTOutGetDomainDetails : public DTOutGeneral {
  Str regDate;
  Str expDate;
  DTOutGetDomainDetails() : regDate( Str() ), expDate( Str() ) {};
};

struct PLUGINTOOLKIT_DECL DTInUpdateDomainNameServers : public DTInOperationDomain {
  DTNameServers nameServers;
  DTInUpdateDomainNameServers() {};
};

struct PLUGINTOOLKIT_DECL DTOutUpdateDomainNameServers : public DTOutOperationDomain {
  DTOutUpdateDomainNameServers() {};
};

struct PLUGINTOOLKIT_DECL DTInUpdateDomainContacts : public DTInOperationDomain {
  DTContacts contacts;
  DTInUpdateDomainContacts() {};
};

struct PLUGINTOOLKIT_DECL DTOutUpdateDomainContacts : public DTOutOperationDomain {
  DTOutUpdateDomainContacts() {};
};

struct PLUGINTOOLKIT_DECL DTInGetDomainNameServersStatus : public DTInOperationDomain {
  DTNameServers nameServers;
  DTInGetDomainNameServersStatus() {};
};

struct PLUGINTOOLKIT_DECL DTOutGetDomainNameServersStatus : public DTOutOperationDomain {
  DTOutGetDomainNameServersStatus() {};
};

struct PLUGINTOOLKIT_DECL DTInGetDomainContactsStatus : public DTInOperationDomain {
  DTContacts contacts;
  DTInGetDomainContactsStatus() {};
};

struct PLUGINTOOLKIT_DECL DTOutGetDomainContactsStatus : public DTOutOperationDomain {
  DTOutGetDomainContactsStatus() {};
};

struct PLUGINTOOLKIT_DECL DTInGetDomainNameServers : public DTInOperationDomain {
  Str domain;
  DTInGetDomainNameServers(const Str& _domain):domain(_domain){}
};

struct PLUGINTOOLKIT_DECL DTOutGetDomainNameServers : public DTOutOperationDomain {
  DTNameServers nameServers;
};

struct PLUGINTOOLKIT_DECL DTInValidateExtData : public DTDomain {
  DTDomainOpType opType; 
  DTExtData extData;     
  DTInValidateExtData() : opType( TOP_REGISTER ) {};
};

struct PLUGINTOOLKIT_DECL DTRegisteredDomainInfo : public DTInDomainData {
  DTNameServers nameServers;
  DTContacts contacts;
  DTRegisteredDomainInfo () {};
};



class DTOutValidateExtData : public DTIOTypeAbstract {
  list<DTTypedExtDataItem> items;
  mutable list<DTTypedExtDataItem>::const_iterator iCur;
public:
  DTOutValidateExtData() : iCur( items.end() ) {}

  void add(
    const Str& key,      
    const Str& type,     
    const Str& title,    
    const Str& descr,    
    const Str& defValue, 
    const bool required,
    const DTExtDataItemStatus status,
    const Str & msg = ""
  )
  {
    items.push_back(DTTypedExtDataItem(key, type, title, descr, defValue, required, status, msg));
  }

  const DTTypedExtDataItem operator [] (const Str& key) {
    for(list<DTTypedExtDataItem>::const_iterator it = items.begin(); it != items.end(); ++it) {
      if (it->paramID == key)
        return *it;
    }
    return DTTypedExtDataItem();
  }

  void clear ()
     { items.clear(); };

  bool next() const {
     if ( items.empty() ) return false;

     if ( iCur == items.end() ) {
       iCur = items.begin();
       return true;
     } else
       return (items.end() != ++iCur);
  };

  const DTTypedExtDataItem & get() const {
    // TODO: Possible SIGFAULT if call get on empty list (get == end)
    return *iCur;
  };
  DTOutValidateExtData &operator= (const DTOutValidateExtData& t) {
    if(this==&t) return *this;
    items = t.items;
    iCur = items.end();
    return *this;
  }

  DTOutValidateExtData(const DTOutValidateExtData& t) : DTIOTypeAbstract(){
    if(this!=&t) {
      items = t.items;
      iCur = items.end();
    }
  }

  friend class DTOutValidateExtDataSerializer;
};

/* Async plug-in processing */
struct PLUGINTOOLKIT_DECL DTInCallback {
  Str data;
  DTInCallback() {};
};

enum DTCallbackItemStatus {
  CBIS_PROCESSING  = 1, 
  CBIS_OK          = 2, 
  CBIS_ERROR       = 3, 
  CBIS_NOT_CHANGED = 4  
};

enum DTCallbackItemType {
  CBIT_OPERATE_DOMAIN = 1, 
  CBIT_UPDATE_DOMAIN  = 2, 
  CBIT_REG_NS         = 3, 
  CBIT_REG_CONTACT    = 4, 
  CBIT_NONE           = 5  
};


struct PLUGINTOOLKIT_DECL DTCallbackResult {
  Str domainName; 
  Str expDate;    
  DTCallbackItemType type; 
  DTCallbackItemStatus status; 

  DTCallbackResult() {type = CBIT_NONE; status = CBIS_NOT_CHANGED;};
};

struct PLUGINTOOLKIT_DECL DTOutCallback : DTOutGeneral {
  list<DTCallbackResult> results;
  DTOutCallback () {};
};


#endif /* DOMAINPLUGINTYPES_H_ */