DdtManager.h

/* -*- Mode: C++; c-file-style: "stroustrup"; indent-tabs-mode: nil -*- */
/*
 * DdtManager.h
 *   Class that calls database and dns routines. This class is an
 *   abstraction layer that allows us to use any implementation of
 *   a database and dns backend.
 *
 * $Id: DdtManager.h,v 1.14 2003/04/24 04:44:56 benoit Exp $
 *
 * Copyright (c) 2000-2001 Remi Lefebvre <remi@dhis.net>
 * Copyright (c) 2000 Benoit Joly <benoit@dhis.net>
 * Copyright (c) 2000 Luca Filipozzi <lfilipoz@dhis.net>
 *
 * DDT comes with ABSOLUTELY NO WARRANTY and is licenced under the
 * GNU General Public License (version 2 or later). This license
 * can be retrieved from http://www.gnu.org/copyleft/gnu.html.
 *
 */

#ifndef DDTMANAGER_H
#define DDTMANAGER_H

//#include <map> // for 0.6

// general defines
#include "global.h"

#include "Logger.h"
#include "Dns.h"
#include "Db.h"

/*
struct runtimeInfo
{
    unsigned long addr;
    // etc ...
};
*/

class DdtManager
{
  public:
    DdtManager(Logger *log, Db *db, Dns *dns);

    ~DdtManager(); 


    /**************  methods for user accounts  **************/

    int addUserAccount(UserAccount *account);

    void delUserAccount(int id);

    void logonUserAccount(int id);

    void logoffUserAccount(int id);

    void updateIPAddress(int id, unsigned long ip);

    void updateTimeStamp(int id);

    void modifyUserAccount(UserAccount *account);



    /****************** methods for dns records *****************/
    
    void addDnsRecord(int id, const char *dname, DnsRecordType type,
                      const char *data);

    void delDnsRecord(int id, const char *dname, DnsRecordType type,
                      const char *data);

    void delDnsRecords(int id);


    void listDnsRecords(int id, std::vector<DnsRecord> &dnsRecordList);


    /***************    compatibility methods only    ****************/
    int markOnline(int id, unsigned int ip) 
        { updateIPAddress(id, ip); return 0; }

    int markOffline(int id) { logoffUserAccount(id); return 0; }

    int markAlive(int id) { updateTimeStamp(id); return 0; }

    bool getAcctInfo (int id, userAccount *account)
        {
            db->fetchAccountInfo(id, account);
            return 0;
        }

    bool fetchAccountInfo(int id, char *field, char *dest, int length)
        {
            UserAccount a;
            db->fetchAccountInfo(id, &a);

            if (strcasecmp(field, "adminPassword") == 0)
                strncpy(dest, a.adminPassword, length);
            else if (strcasecmp(field, "updatePassword") == 0)
                strncpy(dest, a.updatePassword, length);
            else if (strcasecmp(field, "contactName") == 0)
                strncpy(dest, a.contactName, length);
            else if (strcasecmp(field, "contactEmail") == 0)
                strncpy(dest, a.contactEmail, length);
            else if (strcasecmp(field, "arch") == 0)
                strncpy(dest, a.arch, length);
            else if (strcasecmp(field, "os") == 0)
                strncpy(dest, a.os, length);
            else if (strcasecmp(field, "fqdn") == 0)
                strncpy(dest, a.fqdn, length);
            else if (strcasecmp(field, "ipAddress") == 0)
                strncpy(dest, a.ipAddress, length);
            else
                return false;

            return true;
        }

    int findUserAccountIdFromFqdn(char *fqdn)
        { 
            return db->findUserAccountIdFromFqdn(fqdn);
        }

    int modUserAccount(int id, char *field, char *value)
        {
            db->modUserAccount(id, field, value);
            return 0;
        }

    int pruneActiveAccount(void (*func)(int, unsigned long, time_t)) 
        { return db->pruneActiveAccount(func); }

    unsigned long fetchAcctAddr(int uid) { return db->fetchAcctAddr(uid); }


  protected:
    Logger *log;
    Db *db;
    Dns *dns;

//    map<int, runtimeInfo> onlineAccounts; // for 0.6 only
};

#endif // DDTMANAGER_H

---