kopete/protocols/groupwise/libgroupwise/privacymanager.cpp

   1 /*
   2     Kopete Groupwise Protocol
   3     privacymanager.cpp - stores the user's privacy information and maintains it on the server
   4
   5     Copyright (c) 2004      SUSE Linux AG                http://www.suse.com
   6
   7     Kopete (c) 2002-2004 by the Kopete developers <kopete-devel@kde.org>
   8
   9     *************************************************************************
  10     *                                                                       *
  11     * This library is free software; you can redistribute it and/or         *
  12     * modify it under the terms of the GNU Lesser General Public            *
  13     * License as published by the Free Software Foundation; either          *
  14     * version 2 of the License, or (at your option) any later version.      *
  15     *                                                                       *
  16     *************************************************************************
  17 */
  18
  19 #include "client.h"
  20 #include "tasks/privacyitemtask.h"
  21 #include "userdetailsmanager.h"
  22
  23 #include "privacymanager.h"
  24
  25 PrivacyManager::PrivacyManager( Client * client)
  26  : QObject(client), m_client( client )
  27 {
  28 }
  29
  30 PrivacyManager::~PrivacyManager()
  31 {
  32 }
  33
  34 bool PrivacyManager::defaultAllow()
  35 {
  36         return !m_defaultDeny;
  37 }
  38
  39 bool PrivacyManager::defaultDeny()
  40 {
  41         return m_defaultDeny;
  42 }
  43
  44 QStringList PrivacyManager::allowList()
  45 {
  46         return m_allowList;
  47 }
  48
  49 QStringList PrivacyManager::denyList()
  50 {
  51         return m_denyList;
  52 }
  53
  54 bool PrivacyManager::isPrivacyLocked()
  55 {
  56         return m_locked;
  57 }
  58
  59 bool PrivacyManager::isBlocked( const QString & dn )
  60 {
  61         if ( m_defaultDeny )
  62                 return !m_allowList.contains( dn );
  63         else
  64                 return m_denyList.contains( dn );
  65 }
  66
  67 void PrivacyManager::setAllow( const QString & dn )
  68 {
  69         if ( m_defaultDeny )
  70         {
  71                 if ( !m_allowList.contains( dn ) )
  72                         addAllow( dn );
  73         }
  74         else
  75         {
  76                 if ( m_denyList.contains( dn ) )
  77                         removeDeny( dn );
  78         }
  79 }
  80
  81 void PrivacyManager::setDeny( const QString & dn )
  82 {
  83         if ( m_defaultDeny )
  84         {
  85                 if ( m_allowList.contains( dn ) )
  86                         removeAllow( dn );
  87         }
  88         else
  89         {
  90                 if ( !m_denyList.contains( dn ) )
  91                         addDeny( dn );
  92         }
  93 }
  94
  95
  96 void PrivacyManager::setDefaultAllow( bool allow )
  97 {
  98         PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
  99         pit->defaultPolicy( !allow );
 100         connect( pit, SIGNAL( finished() ), SLOT( slotDefaultPolicyChanged() ) );
 101         pit->go( true );
 102 }
 103
 104 void PrivacyManager::setDefaultDeny( bool deny )
 105 {
 106         PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 107         pit->defaultPolicy( deny);
 108         connect( pit, SIGNAL( finished() ), SLOT( slotDefaultPolicyChanged() ) );
 109         pit->go( true );
 110 }
 111
 112 void PrivacyManager::addAllow( const QString & dn )
 113 {
 114         // start off a CreatePrivacyItemTask
 115         PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 116         pit->allow( dn );
 117         connect( pit, SIGNAL( finished() ), SLOT( slotAllowAdded() ) );
 118         pit->go( true );
 119 }
 120
 121 void PrivacyManager::addDeny( const QString & dn )
 122 {
 123         // start off a CreatePrivacyItemTask
 124         PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 125         pit->deny( dn );
 126         connect( pit, SIGNAL( finished() ), SLOT( slotDenyAdded() ) );
 127         pit->go( true );
 128 }
 129
 130 void PrivacyManager::removeAllow( const QString & dn )
 131 {
 132         PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 133         pit->removeAllow( dn );
 134         connect( pit, SIGNAL( finished() ), SLOT( slotAllowRemoved() ) );
 135         pit->go( true );
 136 }
 137
 138 void PrivacyManager::removeDeny( const QString & dn )
 139 {
 140         // start off a CreatePrivacyItemTask
 141         PrivacyItemTask * pit = new PrivacyItemTask( m_client->rootTask() );
 142         pit->removeDeny( dn );
 143         connect( pit, SIGNAL( finished() ), SLOT( slotDenyRemoved() ) );
 144         pit->go( true );
 145 }
 146
 147 void PrivacyManager::setPrivacy( bool defaultIsDeny, const QStringList & allowList, const QStringList & denyList )
 148 {
 149         if ( defaultIsDeny != m_defaultDeny )
 150                 setDefaultDeny( defaultIsDeny );
 151         // find the DNs no longer in the allow list
 152         QStringList allowsToRemove = difference( m_allowList, allowList );
 153         // find the DNs no longer in the deny list
 154         QStringList denysToRemove = difference( m_denyList, denyList );
 155         // find the DNs new in the allow list
 156         QStringList allowsToAdd = difference( allowList, m_allowList );
 157         // find the DNs new in the deny list
 158         QStringList denysToAdd = difference( denyList, m_denyList );
 159
 160         QStringList::ConstIterator end = allowsToRemove.constEnd();
 161         for ( QStringList::ConstIterator it = allowsToRemove.constBegin(); it != end; ++it )
 162                 removeAllow( *it );
 163         end = denysToRemove.constEnd();
 164         for ( QStringList::ConstIterator it = denysToRemove.constBegin(); it != end; ++it )
 165                 removeDeny( *it );
 166         end = allowsToAdd.constEnd();
 167         for ( QStringList::ConstIterator it = allowsToAdd.constBegin(); it != end; ++it )
 168                 addAllow( *it );
 169         end = denysToAdd.constEnd();
 170         for ( QStringList::ConstIterator it = denysToAdd.constBegin(); it != end; ++it )
 171                 addDeny( *it );
 172 }
 173
 174 void PrivacyManager::slotGotPrivacySettings( bool locked, bool defaultDeny, const QStringList & allowList, const QStringList & denyList )
 175 {
 176         m_locked = locked;
 177         m_defaultDeny = defaultDeny;
 178         m_allowList = allowList;
 179         m_denyList = denyList;
 180 }
 181
 182 void PrivacyManager::getDetailsForPrivacyLists()
 183 {
 184         if ( !m_allowList.isEmpty() )
 185         {
 186                 m_client->userDetailsManager()->requestDetails( m_allowList );
 187         }
 188         if ( !m_denyList.isEmpty() )
 189                 m_client->userDetailsManager()->requestDetails( m_denyList );
 190 }
 191
 192 void PrivacyManager::slotDefaultPolicyChanged()
 193 {
 194         PrivacyItemTask * pit = ( PrivacyItemTask * )sender();
 195         if ( pit->success() )
 196                 m_defaultDeny = pit->defaultDeny();
 197 }
 198
 199 void PrivacyManager::slotAllowAdded()
 200 {
 201         PrivacyItemTask * pit = ( PrivacyItemTask * )sender();
 202         if ( pit->success() )
 203         {
 204                 m_allowList.append( pit->dn() );
 205                 emit privacyChanged( pit->dn(), isBlocked( pit->dn() ) );
 206         }
 207 }
 208
 209 void PrivacyManager::slotDenyAdded()
 210 {
 211         PrivacyItemTask * pit = ( PrivacyItemTask * )sender();
 212         if ( pit->success() )
 213         {
 214                 m_denyList.append( pit->dn() );
 215                 emit privacyChanged( pit->dn(), isBlocked( pit->dn() ) );
 216         }
 217 }
 218
 219 void PrivacyManager::slotAllowRemoved()
 220 {
 221         PrivacyItemTask * pit = ( PrivacyItemTask * )sender();
 222         if ( pit->success() )
 223         {
 224                 m_allowList.removeAll( pit->dn() );
 225                 emit privacyChanged( pit->dn(), isBlocked( pit->dn() ) );
 226         }
 227 }
 228
 229 void PrivacyManager::slotDenyRemoved()
 230 {
 231         PrivacyItemTask * pit = ( PrivacyItemTask * )sender();
 232         if ( pit->success() )
 233         {
 234                 m_denyList.removeAll( pit->dn() );
 235                 emit privacyChanged( pit->dn(), isBlocked( pit->dn() ) );
 236         }
 237 }
 238
 239 QStringList PrivacyManager::difference( const QStringList & lhs, const QStringList & rhs )
 240 {
 241         QStringList diff;
 242         const QStringList::ConstIterator lhsEnd = lhs.constEnd();
 243         const QStringList::ConstIterator rhsEnd = rhs.constEnd();
 244         for ( QStringList::ConstIterator lhsIt = lhs.constBegin(); lhsIt != lhsEnd; ++lhsIt )
 245         {
 246                 if ( !rhs.contains( *lhsIt ) )
 247                         diff.append( *lhsIt );
 248         }
 249         return diff;
 250 }
 251 #include "privacymanager.moc"