root/DRIM_GUI/lime-user/trunk/libsrc/qrfuser.cpp

#include <qvariant.h>
#include <qheader.h>
#include <qlistview.h>
#include <qtabwidget.h>
#include <qwidget.h>
#include <qlayout.h>
#include <qtooltip.h> 
#include <qwhatsthis.h>                          
#include <qaction.h>
#include <qmenubar.h>
#include <qpopupmenu.h>
#include <qtoolbar.h>
#include <qimage.h>
#include <qpixmap.h>
#include <qcolor.h>
#include <qinputdialog.h>
#include <qfont.h>
#include <qwindowsstyle.h>
#include <qtextcodec.h>
#include <qapplication.h>
#include <qfiledialog.h>
#include <qregexp.h>
#include <qmessagebox.h>

#include "lime-user.h"
#include "qrfuser.h"
#include "qaddnew.h"
#include "qaddnewgroup.h"
#include "qusersetupform.h"
#include "qgroupsetupform.h"
#include "qsetpwdform.h"
#include "libdefine.h"
#include "corefile/define.h"
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>
#include <map>
#include <vector>
#include <string>

#include "icons/addgroup.xpm"
#include "icons/adduser.xpm"
#include "icons/del.xpm"
#include "icons/fresh.xpm"
#include "icons/general.xpm"
#include "icons/hide_system.xpm"
#include "icons/info.xpm"
#include "icons/main.xpm"
#include "icons/manual.xpm"
#include "icons/properites.xpm"
#include "icons/rename.xpm"
#include "icons/show_all.xpm"
#include "icons/smalluser.xpm"
#include "icons/kuser.xpm"
#include "icons/commonuser.xpm"
#include "icons/commonuser-small.xpm"
#include "icons/systemuser.xpm"
#include "icons/systemuser-small.xpm"
#include "icons/commongroup.xpm"
#include "icons/commongroup-small.xpm"
#include "icons/systemgroup.xpm"
#include "icons/systemgroup-small.xpm"

#include <qfileinfo.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

using namespace std;
bool displayAll = false;

RFMSnapin* CreateSnapinInstance(RFMConsole *c, QObject *parent) 
{
        bindtextdomain (PACKAGE,LOCALEDIR);
        return new RfUserMinSnapin(c, parent);
}

RfUserMinSnapin::RfUserMinSnapin(RFMConsole *c, QObject *parent, const char *name)
                :RFMSnapin(c, parent, name)
{
        setRootItem(new QRFUserMin(c->getPivotRoot(),c));
}

void RfUserMinSnapin::initConsole()
{
        RFMConsole *c = getConsole();
        if(!c) return;

        RFMConsole::CommandItem cmds[] = {
                {ID_ADDNEWUSER, QIconSet(QPixmap((char **)adduser_xpm)),_("Add new &User"),_("Add new user"),_("Add new user"), QString::null, 0, 0},
                {ID_ADDNEWGROUP, QIconSet(QPixmap((char **)addgroup_xpm)),_("Add new &Group"),_("Add new group"),_("Add new group"), QString::null, 0, 0},
                {ID_RENAME, QIconSet(QPixmap((char **)rename_xpm)),_("&Rename"),_("Rename the current user or group"),_("Rename the current user or group"),
                        QString::null, 0, 0},
                {ID_DELETE, QIconSet(QPixmap((char **)del_xpm)),_("&Delete"),_("Delete"),_("Delete"), QString::null, 0, 0},
                {ID_REFRESH, QIconSet(QPixmap((char **)fresh_xpm)),_("&Refresh"),_("Refresh"),_("Refresh"), QString::null, 0, 0},
                { ID_SWITCHER, QIconSet(QPixmap(show_all_xpm)),_("&Show all accounts"),_("Show all accounts"),
                                _("Show all users and groups"), QString::null, 0, 0},
                {0, QIconSet(), QString::null, QString::null, QString::null, QString::null, 0, 0}
        };

        for(int i=0; cmds[i].id; ++i) {
                c->allocateCommandItem(cmds[i]);
        }
}

void RfUserMinSnapin::onHostChange(RFMConsole *c,HostItem *hostItem)
{
        (static_cast<QRFUserMin*>(getRootItem()))->onHostChange(c,hostItem);
}

void RfUserMinSnapin::onHostDelete(RFMConsole *c,HostItem *hostItem)
{
        (static_cast<QRFUserMin*>(getRootItem()))->onHostDelete(c,hostItem);
}

QString RfUserMinSnapin::getTitle() const {
        return _("User and Group Manager");
}

QString RfUserMinSnapin::getDescription() const {
        return getTitle();
}

QString RfUserMinSnapin::getProvider() const {
        return _("Red Flag Software Ltd.");
}

QString RfUserMinSnapin::getVersion() const {
#ifdef PACKAGE_VERSION
        return PACKAGE_VERSION;
#else 
        return "unknown version";
#endif
}

QString RfUserMinSnapin::getHelpAddr() const {
#ifdef PKGDOCDIR
     QString manual;
     QString locale = QTextCodec::locale();
     locale = locale.section('.',0,0);
     manual = PKGDOCDIR"/lime-user_manual_"+locale+".xml";
     QFileInfo finfo(manual);
     if(!finfo.exists())
          manual = PKGDOCDIR"/lime-user_manual.xml";
     return manual;
#endif
        return QString::null;
}


QRFUserMin::QRFUserMin(RFMScopeItem * parent,RFMConsole * c) : RFMScopeItem(parent, Static,1),console(c)
{
        userList=NULL;
        groupList=NULL;
        currentHostItem=NULL;
        userItem=new UserItem(this);
        groupItem=new GroupItem(this);
}


QRFUserMin::~QRFUserMin()
{
        while(! hostDataMap.empty())
        {
                onHostDelete(getConsole(),hostDataMap.begin()->first);
        }
        for(vector<MyAssociator*>::iterator mpos=associatorList.begin();mpos!=associatorList.end();mpos++)
        {
                delete *mpos;
        }
        associatorList.clear();
}

QString QRFUserMin::text(int column) const
{
        if(column == 0)
                return _("User Management");
        else return QString::null;
}


QPixmap * QRFUserMin::pixmap(int column, QIconSet::Size size, QIconSet::Mode mode, QIconSet::State state) const
{
        Q_UNUSED(mode);
        Q_UNUSED(state);
        QPixmap *p = NULL;
        if(column == 0) {
                if(size == QIconSet::Automatic || size == QIconSet::Small) {
                        p = new QPixmap((const char**)lime_user_small_xpm);
                }
                else if(size == QIconSet::Large) {
                        p = new QPixmap((const char**)lime_user_xpm);
                }
        }
        return p;
}

void QRFUserMin::onHostChange(RFMConsole *c,HostItem *hostItem)
{
        int ret=0;
        if(hostItem == NULL) return ;
        //auth failed, then sucess not refresh
        if(userItem) userItem->clearResultItem();
        if(groupItem) groupItem->clearResultItem();
        if(currentHostItem)
        {
                map<HostItem*,HostData*>::iterator it=hostDataMap.find(currentHostItem);
                if(it==hostDataMap.end())
                {
                        HostData * hd=new HostData;
                        hd->userList=userList;
                        hd->groupList=groupList;
                        hostDataMap.insert(pair<HostItem*,HostData*>(currentHostItem,hd));
                }
                else
                {
                        HostData * hd=NULL;
                        if(!(*it).second)
                        {
                                hd=new HostData;
                                hostDataMap.insert(pair<HostItem*,HostData*>(currentHostItem,hd));
                        }
                        hd=(*it).second;
                        hd->userList=userList;
                        hd->groupList=groupList;
                }
        }
        if(hostItem)
        {
                map<HostItem*,HostData*>::iterator it=hostDataMap.find(hostItem);
                if(it==hostDataMap.end())
                {
                        HostData * hd=new HostData;
                        hostDataMap.insert(pair<HostItem*,HostData*>(hostItem,hd));
                        userList=hd->userList=NULL;
                        groupList=hd->groupList=NULL;
                }
                else
                {
                        HostData * hd=NULL;
                        if(!(*it).second)
                        {
                                hd=new HostData;
                                userList=hd->userList=NULL;
                                groupList=hd->groupList=NULL;
                                hostDataMap.insert(pair<HostItem*,HostData*>(hostItem,hd));
                        }
                        else
                        {
                                hd=(*it).second;
                                userList=hd->userList;
                                groupList=hd->groupList;
                        }
                }
        }
        currentHostItem=hostItem;
        if(currentHostItem == NULL || currentHostItem->client==NULL)  return;

        bool flag=false;
        if(userList==NULL)
        {
                flag=RFListAllUsers();
        }
        if(groupList==NULL && flag)
        {
                RFListAllGroups();
        }
        show_data();
}

void QRFUserMin::onHostDelete(RFMConsole * c, HostItem * hostItem)
{
        map<HostItem*,HostData*>::iterator it=hostDataMap.find(hostItem);
        if(it!=hostDataMap.end())
        {
                HostData * hd=(*it).second;
                if(hd)
                {
                        if(hd->userList)
                        {
                                for(map<string,User*>::iterator pos=hd->userList->begin();pos!=hd->userList->end();pos++)
                                {
                                        delete (*pos).second;
                                }
                                hd->userList->clear();
                                delete hd->userList;
                        }
                        if(hd->groupList)
                        {
                                for(map<string,Group*>::iterator pos=hd->groupList->begin();pos!=hd->groupList->end();pos++)
                                {
                                        delete (*pos).second;
                                }
                                hd->groupList->clear();
                                delete hd->groupList;
                        }
                        delete hd;
                }
                hostDataMap.erase(it);
        }
}

bool QRFUserMin::onSelect(RFMConsole *c, RFMSelection *s)
{
        RFMScopeItem::onSelect(c , s);
        c->insertCommandButton(ID_REFRESH,RFMConsole::ToolBar);
        c->insertCommandButton(ID_REFRESH,RFMConsole::MenuAction);
}

bool QRFUserMin::onCommand(RFMConsole *c, int commandID, RFMSelection *s)
{
        if(commandID==ID_REFRESH)
        {
                if(RFListAllUsers()) RFListAllGroups();
                RFRefresh();
        }
        return true;
}

bool QRFUserMin::RFListAllUsers()
{
        if(userList==NULL) userList=new map<string,User*>;
        if(currentHostItem == NULL || currentHostItem->client == NULL) return false;
        if(!userList->empty())
        {
                for(map<string,User*>::iterator pos=userList->begin();pos!=userList->end();pos++)       delete(pos->second);
        }
        userList->clear();

        int ret=0;
        try{
                User::fetchUserList(userList,currentHostItem->client);
        }CATCH_EXCEPTION(NULL,_("Fetch user list failed! "),_("Can not fetch the user list from the host!"),ret)
        while(ret==2)
        {
                ret=0;
                if(! getConsole()->getHostListBar()->sltEditHost()) return false;
                currentHostItem=getConsole()->getHostListBar()->currentHostItem();
                try{
                        User::fetchUserList(userList,currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Fetch user list failed! "),_("Can not fetch the user list from the host!"),ret)
        }
        return true;
}

bool QRFUserMin::RFListAllGroups()
{
        if(groupList==NULL) groupList=new map<string,Group*>;
        if(currentHostItem == NULL || currentHostItem->client == NULL) return false;
        if(!groupList->empty())
        {
                for(map<string,Group*>::iterator pos=groupList->begin();pos!=groupList->end();pos++) delete(pos->second);
        }
        groupList->clear();

        int ret=0;
        try{
                Group::fetchGroupList(groupList,currentHostItem->client);
        }CATCH_EXCEPTION(NULL,_("Fetch group list failed! "),_("Can not fetch the group list from the host!"),ret)
        while(ret==2)
        {
                ret=0;
                if(! getConsole()->getHostListBar()->sltEditHost()) return false;
                currentHostItem=getConsole()->getHostListBar()->currentHostItem();
                try{
                        Group::fetchGroupList(groupList,currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Fetch group list failed! "),_("Can not fetch the group list from the host!"),ret)
        }
        for(map<string,Group*>::iterator pos=groupList->begin();pos!=groupList->end();pos++)
        {
                (*pos).second->enumUser(currentHostItem->client);
        }
        return true;
}


void QRFUserMin::show_data()
{
        if(userItem) userItem->show_data();
        if(groupItem) groupItem->show_data();
}

void QRFUserMin::RFAddNewUser()
{
        if(currentHostItem == NULL || currentHostItem->client == NULL) return;
        QAddNewUser* userForm;
        userForm = new QAddNewUser(this);
        userForm->exec();
        if(userItem)
        {
                RFListAllUsers();
                RFListAllGroups();
                userItem->clearResultItem();
                userItem->show_data();
        }
}


void QRFUserMin::RFAddNewGroup()
{
        if(currentHostItem == NULL || currentHostItem->client == NULL) return;
        QAddNewGroup* newGroupForm = new QAddNewGroup( this);
        newGroupForm->exec();
        if(groupItem)
        {
                RFListAllUsers();
                RFListAllGroups();
                groupItem->clearResultItem();
                groupItem->show_data();
        }
}


void QRFUserMin::RFSetUserPropties(QString userName)
{
        User  *userToSet=NULL;
        map<string,User*>::iterator upos=userList->find(userName.latin1());
        if(upos!=userList->end())
        {
                userToSet = upos->second;
        }
        RFSetUserPropties(userToSet);
}

void QRFUserMin::RFSetUserPropties(User  *userToSet)
{
        if(currentHostItem == NULL || currentHostItem->client==NULL || userToSet ==NULL) return;
        for(vector<MyAssociator*>::iterator pos=associatorList.begin();pos!=associatorList.end();pos++)
        {
                delete (*pos);
        }
        associatorList.clear();
        int ret=0;
        try{
             MyAssociator::enumAssociatorFromUser(currentHostItem->client,
                                                  userToSet,groupList,&associatorList);
        }CATCH_EXCEPTION(NULL,_("Enumeration associator of user failed! "),_("Enumeration associator of user failed!"),ret);
        if (ret != 0)
             return;
        QUserSetupForm* userSetupForm = new QUserSetupForm( this, userToSet);
        userSetupForm->exec();
        if(userItem)
        {
                userItem->clearResultItem();
                userItem->show_data();
        }
}

void QRFUserMin::RFSetGroupPropties(QString groupName)
{
        Group *groupToSet=NULL;
        map<string,Group*>::iterator gpos=groupList->find(groupName.latin1());
        if(gpos!=groupList->end())
        {
                groupToSet = gpos->second;
        }
        RFSetGroupPropties(groupToSet);
}

void QRFUserMin::RFSetGroupPropties(Group  *groupToSet)
{
        if(currentHostItem == NULL || currentHostItem->client==NULL || groupToSet==NULL) return;
        int ret=0;
        for(vector<MyAssociator*>::iterator pos=associatorList.begin();pos!=associatorList.end();pos++)
        {
                delete (*pos);
        }
        associatorList.clear();
        try{
                MyAssociator::enumAssociatorFromGroup(currentHostItem->client,
                                                      groupToSet,userList,&associatorList);
        }CATCH_EXCEPTION(NULL,  _("Enumeration associator of group  failed! "),_("Enumeration associator of group  failed!"),ret)
        if (ret != 0)
             return;
        QGroupSetupForm* groupSetupForm = new QGroupSetupForm( this, groupToSet);
        groupSetupForm->exec();
        if(groupItem) 
        {
                groupItem->clearResultItem();
                groupItem->show_data();
        }
}


void    QRFUserMin::RFRefresh()
{
        if(userItem) userItem->clearResultItem();
        if(groupItem) groupItem->clearResultItem();
        show_data();
}

void QRFUserMin::RFAbout()
{
}

void QRFUserMin::RFSetPassword(QString userName)
{
        map<string,User*>::iterator upos=userList->find(userName.latin1());
        if(upos!=userList->end())       RFSetPassword((*upos).second);
}

void QRFUserMin::RFSetPassword(User * user)
{
        if(currentHostItem == NULL || currentHostItem->client==NULL || user ==NULL) return;
        QSetPwdForm* setPwdForm = new QSetPwdForm(this, user);
        setPwdForm->exec();
}

void QRFUserMin::RFDeleteUser(QString userName)
{
        map<string,User*>::iterator upos=userList->find(userName.latin1());
        if(upos==userList->end()) return;
        RFDeleteUser((*upos).second);
}

void QRFUserMin::RFDeleteUser(User * user)
{
        if(currentHostItem== NULL || currentHostItem->client==NULL || user==NULL) return;
        QMessageBox a;

        QString UID=user->uid.c_str();
        bool ok;
        int uid = UID.toInt(&ok, 10);

        if(uid == (int)getuid())
        {
                RFWarn( _("Warning"),_("Ok"), NULL, _("operation denied.") );
                return;
        }
        if(uid<500)
        {
                RFWarn( _("Warning"),_("Ok"), NULL, _("operation denied.") );
                return;
        }
        if(0 != a.warning( NULL, _ ("Warning"),_ ("delete the user from system(the home directory will not be removed),  really do?"),
                                _("Ok"),_("Cancel"),NULL, 0, 1 ))
                return;
        int ret=0;
        try{
                MyAssociator::enumAssociatorFromUser(currentHostItem->client,
                                                     user,groupList,&associatorList);
        }CATCH_EXCEPTION(NULL,_( "Enumeration associator of user failed! "),_( "Enumeration associator of user failed! "),ret);
        if (ret != 0)
             return;
        
        for(vector<MyAssociator*>::iterator pos=associatorList.begin();pos!=associatorList.end();pos++)
        {
                try{
                        (*pos)->deleteMyAssociator(currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Delete associator failed! "),_("Delete associator failed! "),ret);
                if(ret!=0) return; 
                delete(*pos);
        }
        associatorList.clear();
        try{
                user->deleteUser(currentHostItem->client);
        }CATCH_EXCEPTION(NULL,_("Delete user failed! "),_("Delete user failed! "),ret);
        QString userMainGroup=user->mainGroup.c_str();
        map<string,User*>::iterator upos=userList->find(user->name.c_str());
    if(upos!=userList->end()) userList->erase(upos);
        delete user;
        RFListAllGroups();
        if(userItem) userItem->clearResultItem();
        if(groupItem) groupItem->clearResultItem();
        map<string,Group*>::iterator gpos=groupList->find(userMainGroup.latin1());
        if(gpos!=groupList->end())
        {
                try{
                        MyAssociator::enumAssociatorFromGroup(currentHostItem->client,gpos->second,userList,&associatorList);
                }catch(...){}//CATCH_EXCEPTION(this,_("Enumeration associator of group failed!"),
                                //_("Enumeration associator of group failed!"),ret);
                if(associatorList.size()==0) RFDeleteGroup(userMainGroup);
        }
        RFListAllUsers();
        RFListAllGroups();
        RFRefresh();
}

void QRFUserMin::RFDeleteGroup(QString groupName)
{
        map<string,Group*>::iterator gpos=groupList->find(groupName.latin1());
        if(gpos==groupList->end()) return;
        RFDeleteGroup((*gpos).second);
}

void QRFUserMin::RFDeleteGroup(Group * group)
{
        if(currentHostItem == NULL || currentHostItem->client==NULL || group==NULL) return;

        QString GID=group->gid.c_str(); 
        int gid=GID.toInt(0,10);
        if(0 == gid)
        {
                RFWarn( _("Warning"),_("Ok"), NULL, _("operation denied.") );
                return;
        }
        if(gid<500)
        {
                RFWarn( _("Warning"),_("Ok"), NULL, _("operation denied.") );
                return;
        }
        int ret = 0;
        

        try{
             if(group->isMainGroup(currentHostItem->client) == 1)
             {
                  QMessageBox::warning(NULL,_("Delete group failed! "),
                                       _("Can not remove user's primary group."));
                  return;
             }
        }CATCH_EXCEPTION(NULL,_("Delete group failed! "),
                         _("Can not get group information! "),ret);
        if(ret != 0)
             return;

        if(0 != QMessageBox::warning( NULL,      _ ("Warning"), _ ("delete the user group from system,  really do?"),
                                _("Ok"),_("Cancel"),NULL, 0, 1 ))
             return;

        ////////////////////////////////////////////////////////////////////

        for(vector<MyAssociator*>::iterator pos=associatorList.begin();pos!=associatorList.end();pos++)
        {
                delete (*pos);
        }
        associatorList.clear();

        try{
                MyAssociator::enumAssociatorFromGroup(currentHostItem->client,
                                                      group,userList,&associatorList);
        }CATCH_EXCEPTION(NULL,_("Enumeration associator of group  failed! "),_("Enumeration associator of group  failed! "),ret);
        if (ret != 0)
             return;
        for(vector<MyAssociator*>::iterator pos=associatorList.begin();pos!=associatorList.end();pos++)
        {
                try{
                        (*pos)->deleteMyAssociator(currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Delete associator failed! "),_("Delete associator failed! "),ret);
                if(ret!=0) return;
                delete(*pos);
        }
        associatorList.clear();
        try{
                group->deleteGroup(currentHostItem->client);
        }CATCH_EXCEPTION(NULL,_("Delete group failed! "),_("Delete group failed! "),ret);
        map<string,Group*>::iterator gpos=groupList->find(group->name.c_str());
        groupList->erase(gpos);
        delete group;
        RFListAllUsers();
        RFListAllGroups();
        RFRefresh();
}

void QRFUserMin::ejectUserPopupMenu (  QListViewItem *, const QPoint &, int  c ){

        QPopupMenu *fileMenu;

        if(c!=-1)
        {               // not blank place
                fileMenu = new QPopupMenu;       // file sub menu
                fileMenu->insertItem( QIconSet(QPixmap(adduser_xpm)),_("Set Password"), this, SLOT(RFSetPassword()), 67 );
                fileMenu->insertItem( QIconSet(QPixmap(rename_xpm)),_("Rename"), this, SLOT(RFRename()), 65 );
                fileMenu->insertItem( QIconSet(QPixmap(del_xpm)),_("Delete"), this, SLOT(RFDeleteUser()), 68 );
                fileMenu->insertSeparator(4);
                fileMenu->insertItem( QIconSet(QPixmap(properties_xpm)),_("Properties"),this,SLOT(RFSetPropties()), 69 );
                fileMenu->exec(QCursor::pos());
        }
        else
        {
                fileMenu = new QPopupMenu;       // file sub menu
                fileMenu->insertItem( QIconSet(QPixmap(adduser_xpm)),_("Add New User"), this, SLOT(RFAddNewUser()), 67 );
                fileMenu->exec(QCursor::pos());
        }
}

void QRFUserMin::ejectGroupPopupMenu (  QListViewItem *, const QPoint &, int  c )
{
        QPopupMenu *fileMenu;
        if(c!=-1)
        {
                fileMenu = new QPopupMenu;       // file sub menu
                fileMenu->insertItem( QIconSet(QPixmap(del_xpm)),_("Delete"),  this, SLOT(RFDeleteGroup( )), 68 );
                fileMenu->insertItem( QIconSet(QPixmap(rename_xpm)),_("Rename"), this, SLOT(RFRename()), 65 );
                fileMenu->insertSeparator(3);
                fileMenu->insertItem( QIconSet(QPixmap(properties_xpm)),_("Properties"),this, SLOT( RFSetPropties() ), 69 );
                fileMenu->exec(QCursor::pos());
        }
        else
        {
                fileMenu = new QPopupMenu;       // file sub menu
                fileMenu->insertItem( QIconSet(QPixmap(addgroup_xpm)),_("Add New Group"),this,SLOT(RFAddNewGroup()),67);
                fileMenu->exec(QCursor::pos());
        }
}

void  QRFUserMin::RFRenameUser(QString userName)
{
        map<string,User*>::iterator upos=userList->find(userName.latin1());
        if(upos==userList->end()) return;
        RFRenameUser((*upos).second);
}

void  QRFUserMin::RFRenameUser(User * user)
{
        if(currentHostItem == NULL || currentHostItem->client==NULL || user==NULL) return;
        QString s;
        bool ok;
        s.append( _( "Enter new name for \"" ) );
        s.append(user->name.c_str());
        s.append( "\" :");
        QString text= QInputDialog::getText(_( "RenameDialog" ),s,QLineEdit::Normal, QString::null, &ok, NULL );
        if(ok && RFVerifyString(text.latin1())==0 )
        {
                RFWarn( _("Warning"),_("Ok"), NULL, _("invalid name."));
        }
        else if ( ok)
        {
                int ret=0;
                if( text.compare(user->name.c_str())==0 )       return;
                if(userList->find(text.latin1())!=userList->end()) 
                {
                        RFWarn( _("Warning"),_("Ok"),NULL,_("user name already exists."));
                        return;
                }
                //fetch old associators between user and group
                for(vector<MyAssociator*>::iterator mpos=associatorList.begin();mpos!=associatorList.end();mpos++)
                {
                        delete (*mpos);
                }
                associatorList.clear();
                try{
                        MyAssociator::enumAssociatorFromUser(currentHostItem->client,
                                                             user,groupList,&associatorList);
                }CATCH_EXCEPTION(NULL,_("Rename user failed"),_("Enumeration associator of user failed! "),ret);
                //CATCH_EXCEPTION(NULL,_("Enumeration associator of user failed"),_("Enumeration associator of user failed! "),ret);
        if (ret != 0)
             return;
                //clear old associators
                for(vector<MyAssociator*>::iterator mpos=associatorList.begin();mpos!=associatorList.end();mpos++)
                {
                        try{
                                (*mpos)->deleteMyAssociator(currentHostItem->client);
                        }CATCH_EXCEPTION(NULL,_("Rename user failed"),_("Delete associator failed! "),ret);
                        if(ret!=0) return;
                }
                //delete old user
                try{
                        user->deleteUser(currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Rename user failed"),_("Delete user failed! "),ret);
                if(ret!=0) return;
                //modify the new user
            map<string,User*>::iterator upos=userList->find(user->name.c_str());
                if(upos!=userList->end()) userList->erase(upos);
                user->passwdEffective=true;
                user->password.erase();
                user->name=text.latin1();
                //create the new user (no password)
                try{    
                        user->createUser(currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Rename user failed"),_("Create user failed! "),ret);
                if(ret!=0) return;
                //add the new associators as old associator
                for(vector<MyAssociator*>::iterator mpos=associatorList.begin();mpos!=associatorList.end();mpos++)
                {
                        try{
                                (*mpos)->createMyAssociator(currentHostItem->client);
                        }catch(...){}
                        //CATCH_EXCEPTION(NULL,_("Create associator failed! "),_("Create associator failed! "),ret);
                }
                userList->insert(pair<string,User*>(user->name.c_str(),user));
                RFListAllUsers();
                RFListAllGroups();
                RFWarn( _("Warning"),_("Ok"),NULL,_("The old password can not be used any more for this user.\nAn empty password is used instead.\nPlease re-set a new password for this user."));
        }
        RFRefresh();
}


void QRFUserMin::RFRenameGroup(QString groupName)
{
        map<string,Group*>::iterator gpos=groupList->find(groupName.latin1());
        if(gpos==groupList->end()) return;
        RFRenameGroup((*gpos).second);
}

void QRFUserMin::RFRenameGroup(Group * group)
{
     if(currentHostItem == NULL ||currentHostItem->client==NULL || group==NULL) return;
        QString s;
        bool ok;
        s.append( _( "Enter new name for \"" ) );
        s.append(group->name.c_str());
        s.append( "\" :");
        QString text= QInputDialog::getText(_( "RenameDialog" ),s,QLineEdit::Normal, QString::null, &ok, NULL );
        if(ok && RFVerifyString(text.latin1())==0 )
        {
                RFWarn( _("Warning"),_("Ok"), NULL, _("invalid name."));
        }
        else if ( ok)
        {
                int ret=0;
                if( text.compare(group->name.c_str())==0 )   return;
                if(groupList->find(text.latin1())!=groupList->end())
                {
                        RFWarn( _("Warning"),_("Ok"),NULL,_("group name already exists."));
                        return;
                }
                //fetch old associators between user and group
                for(vector<MyAssociator*>::iterator mpos=associatorList.begin();mpos!=associatorList.end();mpos++)
                {
                        delete (*mpos);
                }
                associatorList.clear();
                try{
                        MyAssociator::enumAssociatorFromGroup(currentHostItem->client,
                                                              group,userList,&associatorList);
                }CATCH_EXCEPTION(NULL,_("Rename group failed"),_("Enumeration associator of group failed! "),ret);
                //CATCH_EXCEPTION(NULL,_("Enumeration associator of group failed"),_("Enumeration associator of group failed! "),ret);
        if (ret != 0)
             return;

                //clear old associators
                for(vector<MyAssociator*>::iterator mpos=associatorList.begin();mpos!=associatorList.end();mpos++)
                {
                        try{
                                (*mpos)->deleteMyAssociator(currentHostItem->client);
                        }CATCH_EXCEPTION(NULL,_("Rename group failed"),_("Delete associator failed! "),ret);
                        if(ret!=0) return;
                }
                //delete old group
                try{
                        group->deleteGroup(currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Rename group failed"),_("Delete group failed! "),ret);
                if(ret!=0) return;
                map<string,Group*>::iterator gpos=groupList->find(group->name.c_str());
                if(gpos!=groupList->end()) groupList->erase(gpos);
                group->name=text.latin1();
                //create the new group (no password)
                try{
                        group->createGroup(currentHostItem->client);
                }CATCH_EXCEPTION(NULL,_("Rename group failed"),_("Create group failed! "),ret);
                if(ret!=0) return;
                //add the new associators as old associator
                for(vector<MyAssociator*>::iterator mpos=associatorList.begin();mpos!=associatorList.end();mpos++)
                {
                        try{
                                (*mpos)->createMyAssociator(currentHostItem->client);
                        }catch(...){}
                        //CATCH_EXCEPTION(NULL,_("Create associator failed! "),_("Create associator failed! "),ret);
                }
                groupList->insert(pair<string,Group *>(group->name.c_str(),group));
                RFListAllUsers();
                RFListAllGroups();
        }
        RFRefresh();
}

UserItem::UserItem(QRFUserMin * parent) : RFMScopeItem((RFMScopeItem *)parent)
{
        already=false;
        p=parent;
}

void UserItem::setupListViewColumns(RFMConsole *c)
{
        c->addColumn(_("User Name"));
        c->addColumn(_("User ID"));
        c->addColumn(_("Main Group"));
        c->addColumn(_("Description"));
        c->addColumn(_("Login Shell"));
        c->addColumn(_("Home Direction"));
}
        
QPixmap * UserItem::pixmap(int column, QIconSet::Size size, QIconSet::Mode mode, QIconSet::State state) const
{
     QPixmap *p = NULL;
        static QPixmap *userItems = NULL;
        static QPixmap *userItemsLarge = NULL;
        if(column == 0) {
                if(size == QIconSet::Automatic || size == QIconSet::Small) {
                     if(userItems == NULL)
                        userItems = p = new QPixmap((const char**)commonuser_small);
                     else
                          p = userItems;
                }
                else if(size == QIconSet::Large) {
                     if(userItemsLarge == NULL)
                        userItemsLarge = p = new QPixmap((const char**)commonuser);
                     else
                          p = userItemsLarge;
                }
        }
        return p;
}

bool UserItem::onSelect(RFMConsole *c, RFMSelection *s)
{
        RFMScopeItem::onSelect(c , s);
        c->insertCommandButton(ID_ADDNEWUSER, RFMConsole::ToolBar);
        c->insertCommandButton(ID_ADDNEWUSER, RFMConsole::MenuAction);
        c->insertCommandButton(ID_REFRESH,RFMConsole::ToolBar);
        c->insertCommandButton(ID_REFRESH,RFMConsole::MenuAction);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
        if(p&&c)
        {
                p->onHostChange(c,c->currentHostItem());
        }
        show_data();
        return true;
}

void UserItem::show_data()
{
        if(p && p->currentHostItem!=NULL &&p->currentHostItem->client!=NULL)
        {
                if(!already)
                {
                        if(p->userList==NULL) p->RFListAllUsers();
                        for(map<string,User*>::iterator pos=p->userList->begin();pos!=p->userList->end();pos++)
                        {
                                long int uid=strtoul(pos->second->uid.c_str(),NULL,10);
                                if( displayAll == FALSE && (uid < 500||uid==65534) )
                                {
                                        continue;
                                }
                                UserRecordItem* n=new UserRecordItem(this,(*pos).second);
                                p->getConsole()->insertResultItem(getScopeItemHandle(), n);
                        }
                        already=true;
                }
        }
}

bool UserItem::onCommand(RFMConsole *c, int commandID, RFMSelection *s)
{
        p->onCommand(c , commandID , s);
        if(commandID==ID_ADDNEWUSER)
        {
                if(p)
                {
                        p->RFAddNewUser();
                }
        }
        else if(commandID==ID_SWITCHER)
        {       
                c->removeCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
                c->removeCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
                c->destroyCommandItem(ID_SWITCHER);
                displayAll=!displayAll;
                if(displayAll)
                {
                        RFMConsole::CommandItem cmd = { ID_SWITCHER, QIconSet(QPixmap(hide_system_xpm)),_("&Hide the system accounts"),_("Hide the system accounts"),
                                _("Hide the system users and groups"), QString::null, 0, 0};
                        c->allocateCommandItem(cmd);
                }
                else 
                {
                        RFMConsole::CommandItem cmd = { ID_SWITCHER, QIconSet(QPixmap(show_all_xpm)),_("&Show all accounts"),_("Show all accounts"),
                                _("Show all users and groups"), QString::null, 0, 0};
                        c->allocateCommandItem(cmd);
                }
                c->insertCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
                c->insertCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
                if(p)
                {       
                        p->RFRefresh();
                }
        }       
        return true;
}

QString UserItem::text(int column) const
{
        if(column == 0) return _("User");
        else return QString::null;
}

void UserItem::clearResultItem()
{
        QPtrList<RFMItem> *l = children();
        if(l) {
                QPtrListIterator<RFMItem> it(*l);
                RFMItem *i;
                while((i = it.current()) != 0) {
                        ++it;
                        if(p&&p->getConsole()) {
                                p->getConsole()->removeResultItem(i->getResultItemHandle());
                        }
                        delete i;
                }
                delete l;
                already=false;
        }
}

GroupItem::GroupItem(QRFUserMin * parent): RFMScopeItem((RFMScopeItem *)parent)
{
        already=false;
        p=parent;
}

void GroupItem::setupListViewColumns(RFMConsole *c)
{
        c->addColumn(_("Group Name"));
        c->addColumn(_("Group ID"));
        c->addColumn(_("Group Members"));       
}

QPixmap * GroupItem::pixmap(int column, QIconSet::Size size, QIconSet::Mode mode, QIconSet::State state) const
{
     QPixmap *p = NULL;
        static QPixmap *groupItems = NULL;
        static QPixmap *groupItemsLarge = NULL;
        if(column == 0) {
                if(size == QIconSet::Automatic || size == QIconSet::Small) {
                     if(groupItems == NULL)
                        groupItems = p = new QPixmap((const char**)commongroup_small);
                     else
                          p = groupItems;
                }
                else if(size == QIconSet::Large) {
                     if(groupItemsLarge == NULL)
                        groupItemsLarge = p = new QPixmap((const char**)commongroup);
                     else
                          p = groupItemsLarge;
                }
        }
        return p;
}

bool GroupItem::onSelect(RFMConsole *c, RFMSelection *s)
{
        RFMScopeItem::onSelect(c , s);
        c->insertCommandButton(ID_ADDNEWGROUP, RFMConsole::ToolBar);
        c->insertCommandButton(ID_ADDNEWGROUP, RFMConsole::MenuAction);
        c->insertCommandButton(ID_REFRESH,RFMConsole::ToolBar);
        c->insertCommandButton(ID_REFRESH,RFMConsole::MenuAction);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
        if(p&&c)
        {
                p->onHostChange(c,c->currentHostItem());
        }
        show_data();
}

void GroupItem::show_data()
{
        if(p&&p->currentHostItem!=NULL && p->currentHostItem->client!=NULL)
        {
                if(!already)
                {
                        if(p->groupList==NULL) p->RFListAllGroups();
                        for(map<string,Group*>::iterator gpos=p->groupList->begin();gpos!=p->groupList->end();gpos++)
                        {
                                long int gid=strtoul(gpos->second->gid.c_str(),NULL,10);
                                if( displayAll == FALSE && (gid < 500||gid==65534) )
                                {
                                        continue;
                                }
                                GroupRecordItem* n=new GroupRecordItem(this,(*gpos).second);
                                p->getConsole()->insertResultItem(getScopeItemHandle(), n);
                        }
                        already=true;
                }
        }
}

bool GroupItem::onCommand(RFMConsole *c, int commandID, RFMSelection *s)
{
        p->onCommand(c , commandID , s);
        if(commandID==ID_ADDNEWGROUP)
        {
                if(p)
                {
                        p->RFAddNewGroup();
                }
        }
        else if(commandID==ID_SWITCHER)
        {       
                c->removeCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
                c->removeCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
                c->destroyCommandItem(ID_SWITCHER);
                displayAll=!displayAll;
                if(displayAll)
                {
                        RFMConsole::CommandItem cmd = { ID_SWITCHER, QIconSet(QPixmap(hide_system_xpm)),_("&Hide the system accounts"),_("Hide the system accounts"),
                                _("Hide the system users and groups"), QString::null, 0, 0};
                        c->allocateCommandItem(cmd);
                }
                else
                {
                        RFMConsole::CommandItem cmd = { ID_SWITCHER, QIconSet(QPixmap(show_all_xpm)),_("&Show all accounts"),_("Show all accounts"),
                                _("Show all users and groups"), QString::null, 0, 0};
                        c->allocateCommandItem(cmd);
                }
                c->insertCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
                c->insertCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
                if(p) 
                {
                        p->RFRefresh();
                }
        }
        return true;
}

QString GroupItem::text(int column) const
{
        if(column == 0) return _("Group");
        else return QString::null;
}


void GroupItem::clearResultItem()
{
        QPtrList<RFMItem> *l = children();
        if(l) {
                QPtrListIterator<RFMItem> it(*l);
                RFMItem *i;
                while((i = it.current()) != 0) {
                        ++it;
                        if(p&&p->getConsole()) {
                                p->getConsole()->removeResultItem(i->getResultItemHandle());
                        }
                        delete i;
                }
                delete l;
                already=false;
        }
}


UserRecordItem::UserRecordItem(UserItem *parent,User* u): RFMResultItem((RFMScopeItem *)parent)
{
        p=parent;
        user=u;
}

QString UserRecordItem::text(int column) const
{
        if(user==NULL) return QString::null;
        switch(column)
        {
                case 0:
                        return user->name.c_str();
                case 1:
                        return user->uid.c_str();
                case 2:
                        return user->mainGroup.c_str();
                case 3:
                        return user->description.c_str();
                case 4:
                        return user->shell.c_str();
                case 5:
                        return user->home.c_str();
                default:
                        return QString::null;
        }
}

QPixmap * UserRecordItem::pixmap(int column, QIconSet::Size size, QIconSet::Mode mode, QIconSet::State state) const
{
        
     if(column != 0) 
          return NULL;
     QPixmap *p = NULL;
     static QPixmap *commUserIcon = NULL;
     static QPixmap *commUserIconLarge = NULL;
     static QPixmap *sysUserIcon = NULL;
     static QPixmap *sysUserIconLarge = NULL;
     long int uid=strtoul(user->uid.c_str(),NULL,10);
     bool systemUser = false;
     if(uid < 500 || uid == 65534)
          systemUser = true;
     if(size == QIconSet::Automatic || size == QIconSet::Small) {
          if(systemUser)
          {
               if (sysUserIcon == NULL)
                    sysUserIcon = p = new QPixmap((const char**)systemuser_small);
               else
                    p = sysUserIcon;
          }
          else
          {
               if (commUserIcon == NULL)
                    commUserIcon = p = new QPixmap((const char**)commonuser_small);
               else
                    p = commUserIcon;
          }
     }
     else if(size == QIconSet::Large) {
          if(systemUser)
          {
               if(sysUserIconLarge == NULL)
                    sysUserIconLarge = p = new QPixmap((const char**)systemuser);
               else
                    p = sysUserIconLarge;
          }
          else
          {
               if(commUserIconLarge == NULL)
                    commUserIconLarge = p = new QPixmap((const char**)commonuser);
               else
                    p = commUserIconLarge;
          }
     }
     return p;
}

bool UserRecordItem::onSelect(RFMConsole *c, RFMSelection *s)
{
        c->insertCommandButton(ID_ADDNEWUSER, RFMConsole::ToolBar);
        c->insertCommandButton(ID_ADDNEWUSER, RFMConsole::MenuAction);
        c->insertCommandButton(ID_DELETE, RFMConsole::ToolBar);
        c->insertCommandButton(ID_DELETE, RFMConsole::MenuAction);
        c->insertCommandButton(ID_RENAME, RFMConsole::ToolBar);
        c->insertCommandButton(ID_RENAME, RFMConsole::MenuAction);
        c->insertCommandButton(ID_REFRESH, RFMConsole::ToolBar);
        c->insertCommandButton(ID_REFRESH, RFMConsole::MenuAction);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
        c->insertCommandButton(RFMConsole::CmdProperties, RFMConsole::ToolBar);
        c->setCommandState(RFMConsole::CmdProperties, true, true);
}

bool UserRecordItem::onCommand(RFMConsole *c, int commandID, RFMSelection *s)
{       
        if(p==NULL) return false;
        p->onCommand(c , commandID , s);
        if(commandID == ID_DELETE)
        {
                if(p->p)        p->p->RFDeleteUser(user);
        }
        else if(commandID == ID_RENAME)
        {
                if(p->p)        p->p->RFRenameUser(user);
        }
        return true;
}

bool UserRecordItem::onProperties(RFMConsole *c, RFMSelection* s)
{
        if(p==NULL) return false;
        if(p->p)
        {
                p->p->RFSetUserPropties(user);
        }
}

GroupRecordItem::GroupRecordItem(GroupItem *parent,Group* g): RFMResultItem((RFMScopeItem *)parent)
{
        p=parent;
        group=g;
}

QString GroupRecordItem::text(int column) const
{
        if(group==NULL) return QString::null;
        if(column==0) return group->name.c_str();
        else if(column==1) return group->gid.c_str();
        else if(column==2) 
        {
                QString members;
                for(vector<string>::iterator mpos=group->members->begin(); mpos!=group->members->end();mpos++)
                {
                        if(mpos==group->members->begin()) members=(*mpos).c_str();
                        else  members =members+ ","+(*mpos).c_str();
                }
                return members;
        }
        return QString::null;
}

QPixmap * GroupRecordItem::pixmap(int column, QIconSet::Size size, QIconSet::Mode mode, QIconSet::State state) const
{
        
     if(column != 0) 
          return NULL;
     QPixmap *p = NULL;
     static QPixmap *commGroupIcon = NULL;
     static QPixmap *commGroupIconLarge = NULL;
     static QPixmap *sysGroupIcon = NULL;
     static QPixmap *sysGroupIconLarge = NULL;
     long int uid=strtoul(group->gid.c_str(),NULL,10);
     bool systemGroup = false;
     if(uid < 500 || uid == 65534)
          systemGroup = true;
     if(size == QIconSet::Automatic || size == QIconSet::Small) {
          if(systemGroup)
          {
               if (sysGroupIcon == NULL)
                    sysGroupIcon = p = new QPixmap((const char**)systemgroup_small);
               else
                    p = sysGroupIcon;
          }
          else
          {
               if (commGroupIcon == NULL)
                    commGroupIcon = p = new QPixmap((const char**)commongroup_small);
               else
                    p = commGroupIcon;
          }
     }
     else if(size == QIconSet::Large) {
          if(systemGroup)
          {
               if(sysGroupIconLarge == NULL)
                    sysGroupIconLarge = p = new QPixmap((const char**)systemgroup);
               else
                    p = sysGroupIconLarge;
          }
          else
          {
               if(commGroupIconLarge == NULL)
                    commGroupIconLarge = p = new QPixmap((const char**)commongroup);
               else
                    p = commGroupIconLarge;
          }
     }
     return p;
}

bool GroupRecordItem::onSelect(RFMConsole *c, RFMSelection *s)
{
        c->insertCommandButton(ID_ADDNEWGROUP, RFMConsole::ToolBar);
        c->insertCommandButton(ID_ADDNEWGROUP, RFMConsole::MenuAction);
        c->insertCommandButton(ID_DELETE, RFMConsole::ToolBar);
        c->insertCommandButton(ID_DELETE, RFMConsole::MenuAction);
        c->insertCommandButton(ID_RENAME, RFMConsole::ToolBar);
        c->insertCommandButton(ID_RENAME, RFMConsole::MenuAction);
        c->insertCommandButton(ID_REFRESH, RFMConsole::ToolBar);
        c->insertCommandButton(ID_REFRESH, RFMConsole::MenuAction);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::ToolBar);
        c->insertCommandButton(ID_SWITCHER, RFMConsole::MenuAction);
        c->insertCommandButton(RFMConsole::CmdProperties, RFMConsole::ToolBar);
        c->setCommandState(RFMConsole::CmdProperties, true, true);
}

bool GroupRecordItem::onCommand(RFMConsole *c, int commandID, RFMSelection *s)
{
        if(p==NULL) return false;
        p->onCommand(c , commandID , s);
        if(commandID == ID_DELETE)
        {
                if(p->p)
                        p->p->RFDeleteGroup(group);
        }
        else if(commandID == ID_RENAME)
        {
                if(p->p)        p->p->RFRenameGroup(group);
        }
        return true;
}

bool GroupRecordItem::onProperties(RFMConsole *c, RFMSelection* s)
{
        if(p==NULL) return false;
        if(p->p)
                p->p->RFSetGroupPropties(group);
}