Changeset 86 for Mulberry/branches/v4.1d1/Sources_Common/Mail/AddressBook/CAddressBook.cp

Timestamp:

07/09/07 10:02:18 (2 years ago)

Author:

daboo

Message:

Some 4.1 changes. Mostly vCard/CardDAV and CalDAV scheduling support.

Files:

• Mulberry/branches/v4.1d1/Sources_Common/Mail/AddressBook/CAddressBook.cp (modified) (29 diffs)

Mulberry/branches/v4.1d1/Sources_Common/Mail/AddressBook/CAddressBook.cp

@@ -25 +25 @@
 
 #include "CAddressBookManager.h"
+#include "CAdbkProtocol.h"
 #include "CCharSpecials.h"
+#include "CLog.h"
 #include "CMailControl.h"
 #include "CPreferences.h"
 #include "CStringUtils.h"
 
+#include "CVCardStoreXML.h"                                     // Share XML defintions with calendar store
+#include "CVCardMapper.h"
+
+#include "CVCardAddressBook.h"
+#include "CVCardVCard.h"
+
 #include <strstream>
 
+#include "XMLDocument.h"
+#include "XMLNode.h"
+#include "XMLObject.h"
+
+using namespace vcardstore;
+
 cdmutex CAddressBook::_mutex;                                                                           // Used for locks
 
-// Copy constructor
-CAddressBook::CAddressBook(const CAddressBook& copy)
-{
-        InitAddressBook();
-        
-        mAdbkName = copy.mAdbkName;
-        mFlags = copy.mFlags;
+// This constructs the address book manager root
+CAddressBook::CAddressBook()
+{
+        mProtocol = NULL;
+        mParent = NULL;
+        mChildren = new CAddressBookList;                               // Root must always have list
+        mChildren->set_delete_data(false);
+        SetFlags(eIsProtocol, true);
+        SetFlags(eIsDirectory, true);
+        SetFlags(eHasExpanded, true);
+        mShortName = mName.c_str();
+        mSize = ULONG_MAX;
+        mLastSync = 0;
+        mACLs = NULL;
+        mRefCount = 0;
+        mVCardAdbk = NULL;
+}
+
+// This constructs the root of a protocol
+CAddressBook::CAddressBook(CAdbkProtocol* proto)
+{
+        mProtocol = proto;
+        mParent = &CAddressBookManager::sAddressBookManager->GetRoot();
+        mChildren = NULL;
+        SetFlags(eIsProtocol, true);
+        SetFlags(eIsDirectory, true);
+        SetFlags(eHasExpanded, true);
+        mName = proto->GetAccountName();
+        mShortName = mName.c_str();
+        mSize = ULONG_MAX;
+        mLastSync = 0;
+        mACLs = NULL;
+        mVCardAdbk = NULL;
+}
+
+// This constructs an actual node
+CAddressBook::CAddressBook(CAdbkProtocol* proto, CAddressBook* parent, bool is_adbk, bool is_dir, const cdstring& name)
+{
+        mProtocol = proto;
+        mParent = parent;
+        mChildren = NULL;                               // Root must always have list
+        SetFlags(eIsAdbk, is_adbk);
+        SetFlags(eIsDirectory, is_dir);
+        mName = name;
+        mSize = ULONG_MAX;
+        mLastSync = 0;
+        mACLs = NULL;
+        mRefCount = 0;
+        mVCardAdbk = NULL;
+
+        SetShortName();
 }
 
@@ -46 +104 @@
 CAddressBook::~CAddressBook()
 {
-        CAddressBookManager::sAddressBookManager->SyncAddressBook(this, false);
-
+        // Do not sync the store root
+        if (mProtocol != NULL)
+                CAddressBookManager::sAddressBookManager->SyncAddressBook(this, false);
+
+        // Deactivate/delete all children
+        Clear();
+        ClearContents();
+        
+        delete mACLs;
         mACLs = NULL;
 }
 
-// Initialization
-void CAddressBook::InitAddressBook()
-{
-        mACLs = NULL;
-        mRefCount = 0;
+cdstring CAddressBook::GetAccountName(bool multi) const
+{
+        cdstring name;
+        if (multi)
+        {
+                name = mProtocol->GetAccountName();
+                name += cMailAccountSeparator;
+        }
+        name += GetName();
+        return name;
+}
+
+void CAddressBook::CheckSize()
+{
+        GetProtocol()->SizeAdbk(this);
+}
+
+void CAddressBook::SyncNow() const
+{
+        time_t now = ::time(NULL);
+        mLastSync = ::mktime(::gmtime(&now));
+}
+
+bool CAddressBook::IsCached() const
+{
+        // Cached if not disconnected or known to have 
+        return !GetProtocol()->IsDisconnected() || mFlags.IsSet(eIsCached);
+}
+
+cdstring CAddressBook::GetURL(bool full) const
+{
+        cdstring ruri = GetName();
+        ruri.EncodeURL(GetProtocol()->GetDirDelim());
+
+        cdstring result = mProtocol->GetURL(full);
+        result += "/";
+        result += ruri;
+        return result;
+}
+
+void CAddressBook::AddChild(CAddressBook* child, bool sort)
+{
+        // Create if required
+        if (mChildren == NULL)
+                mChildren = new CAddressBookList;
+        mChildren->push_back(child);
+        child->mParent = this;
+        
+        // Setting a child means it has been expanded
+        SetFlags(eHasExpanded, true);
+        
+        // Do sort if requested
+        if (sort)
+                SortChildren();
+}
+
+void CAddressBook::AddChildHierarchy(CAddressBook* child, bool sort)
+{
+        // Only do this if its the protocol root
+        if (mParent != &CAddressBookManager::sAddressBookManager->GetRoot())
+                return;
+
+        // Break the name down into components
+        cdstrvect names;
+        const char* start = child->GetName().c_str();
+        const char* end = ::strchr(start, mProtocol->GetDirDelim());
+        while(end != NULL)
+        {
+                names.push_back(cdstring(start, end - start));
+                start = end + 1;
+                end = ::strchr(start, mProtocol->GetDirDelim());
+        }
+
+        // Find each path component
+        CAddressBook* parent = this;
+        cdstring path;
+        for(cdstrvect::const_iterator iter1 = names.begin(); iter1 != names.end(); iter1++)
+        {
+                // Get path component
+                if (!path.empty())
+                        path += mProtocol->GetDirDelim();
+                path += *iter1;
+                
+                // Find the node
+                bool found = false;
+                for(CAddressBookList::iterator iter2 = parent->GetChildren()->begin(); iter2 != parent->GetChildren()->end(); iter2++)
+                {
+                        if ((*iter2)->GetName() == path)
+                        {
+                                parent = *iter2;
+                                found = true;
+                                break;
+                        }
+                }
+                
+                // If not found, create a directory and make it the new parent
+                if (!found)
+                {
+                        CAddressBook* adbk = new CAddressBook(mProtocol, parent, false, true, path);
+                        parent->AddChild(adbk, sort);
+                        parent = adbk;
+                }
+        }
+
+        // Now add to actual parent
+        parent->AddChild(child, sort);
+}
+
+void CAddressBook::InsertChild(CAddressBook* child, uint32_t index, bool sort)
+{
+        // Do ordinary add if no children or insert at end
+        if ((mChildren == NULL) || (index >= mChildren->size()))
+                AddChild(child, sort);
+        else
+        {
+                mChildren->insert(mChildren->begin() + index, child);
+                child->mParent = this;
+                
+                // Do sort if requested
+                if (sort)
+                        SortChildren();
+        }
+}
+
+void CAddressBook::SortChildren()
+{
+        if (mChildren == NULL)
+                return;
+        
+        std::sort(mChildren->begin(), mChildren->end(), sort_by_name);
+}
+
+bool CAddressBook::sort_by_name(const CAddressBook* s1, const CAddressBook* s2)
+{
+        return ::strcmpnocase(s1->GetShortName(), s2->GetShortName()) < 0;
+}
+
+CAddressBook* CAddressBook::FindNode(cdstrvect& hierarchy, bool discover) const
+{
+        // Find top-level item matching last item in hierarchy
+        if (mChildren)
+        {
+                for(CAddressBookList::iterator iter = mChildren->begin(); iter != mChildren->end(); iter++)
+                {
+                        if (hierarchy.back() == (*iter)->GetShortName())
+                        {
+                                hierarchy.pop_back();
+                                if (hierarchy.empty())
+                                        return *iter;
+                                else
+                                {
+                                        // May need discovery
+                                        if (discover && (*iter)->IsDirectory() && !(*iter)->HasExpanded())
+                                                GetProtocol()->LoadSubList(*iter, false);                                       
+                                        return (*iter)->FindNode(hierarchy, discover);
+                                }
+                        }
+                }
+        }
+        
+        return NULL;
+}
+
+// Remove node from parent withtout deleting the node
+void CAddressBook::RemoveFromParent()
+{
+        if (mParent)
+        {
+                CAddressBookList* list = mParent->GetChildren();
+                CAddressBookList::iterator found = ::find(list->begin(), list->end(), this);
+                if (found != list->end())
+                {
+                        // NULL it out so that the node is not deleted, then erase
+                        *found = NULL;
+                        list->erase(found);
+                }
+                
+                mParent = NULL;
+        }
+}
+
+void CAddressBook::Clear()
+{
+        if (mChildren != NULL)
+        {
+                // Erase children
+                delete mChildren;
+                mChildren = NULL;
+        }
+}
+
+uint32_t CAddressBook::GetRow() const
+{
+        // Look for sibling
+        uint32_t row = GetParentOffset();
+        const CAddressBook* parent = mParent;
+        while(parent != NULL)
+        {
+                row += parent->GetParentOffset();
+                parent = parent->mParent;
+        }
+        
+        return row;
+}
+
+uint32_t CAddressBook::CountDescendants() const
+{
+        uint32_t result = 0;
+        if (mChildren != NULL)
+        {
+                for(CAddressBookList::iterator iter = mChildren->begin(); iter != mChildren->end(); iter++)
+                        result += (*iter)->CountDescendants() + 1;
+        }
+        
+        return result;
+}
+
+uint32_t CAddressBook::GetParentOffset() const
+{
+        uint32_t result = 0;
+        if ((mParent != NULL) && mParent->HasInferiors())
+        {
+                result++;
+                for(CAddressBookList::iterator iter = mParent->GetChildren()->begin(); iter != mParent->GetChildren()->end(); iter++)
+                {
+                        if (*iter == this)
+                                break;
+                        
+                        result += (*iter)->CountDescendants() + 1;
+                }
+        }
+        
+        return result;
+}
+
+const CAddressBook* CAddressBook::GetSibling() const
+{
+        const CAddressBook* result = NULL;
+        if ((mParent != NULL) && mParent->HasInferiors())
+        {
+                for(CAddressBookList::iterator iter = mParent->GetChildren()->begin(); iter != mParent->GetChildren()->end(); iter++)
+                {
+                        if (*iter == this)
+                                break;
+                        
+                        result = *iter;
+                }
+        }
+        
+        return result;
+}
+
+void CAddressBook::GetInsertRows(uint32_t& parent_row, uint32_t& sibling_row) const
+{
+        // Get parent's row
+        parent_row = (mParent ? mParent->GetRow() : 0);
+
+        // Now get the sibling row
+        uint32_t parent_offset = GetParentOffset();
+        if ((parent_offset != 0) && (GetSibling() != NULL))
+        {
+                sibling_row = parent_row + parent_offset - GetSibling()->CountDescendants() - 1;
+        }
+        else
+                sibling_row = 0;
+}
+
+// Set pointer to short name
+void CAddressBook::SetShortName()
+{
+        // Determine last directory break
+        const char* p = NULL;
+        if ((GetProtocol()->GetDirDelim() != 0) && ((p = ::strrchr(mName.c_str(), mProtocol->GetDirDelim())) != NULL))
+                mShortName = ++p;
+        else
+                mShortName = mName.c_str();
+}
+
+// Tell this and children to adjust names
+void CAddressBook::NewName(const cdstring& name)
+{
+        // Adjust this one
+        SetName(name);
+        
+        // Now iterate over children doing rename
+        if (mChildren != NULL)
+        {
+                for(CAddressBookList::iterator iter = mChildren->begin(); iter != mChildren->end(); iter++)
+                {
+                        (*iter)->ParentRenamed();
+                }
+        }
+}
+
+// Tell children to adjust names when parent moves
+void CAddressBook::ParentRenamed()
+{
+        // Must have a parent
+        if (mParent == NULL)
+                return;
+
+        // Adjust this node
+        cdstring new_name;
+        new_name = mParent->GetName();
+        if (GetProtocol()->GetDirDelim())
+                new_name += GetProtocol()->GetDirDelim();
+        new_name += GetShortName();
+        SetName(new_name);
+        
+        // Now iterate over children doing rename
+        if (mChildren != NULL)
+        {
+                for(CAddressBookList::iterator iter = mChildren->begin(); iter != mChildren->end(); iter++)
+                {
+                        (*iter)->ParentRenamed();
+                }
+        }
+}
+
+void CAddressBook::MoveAddressBook(const CAddressBook* dir, bool sibling)
+{
+#ifdef TODO
+#endif
+}
+
+// Copy this address book into another one
+void CAddressBook::CopyAddressBook(CAddressBook* node)
+{
+#ifdef TODO
+#endif
+}
+
+// Copy this address book's items into another one
+void CAddressBook::CopyAddressBookContents(CAddressBook* node)
+{
+#ifdef TODO
+#endif
+}
+
+// Switch into disconnected mode
+void CAddressBook::TestDisconnectCache()
+{
+        if (mChildren != NULL)
+        {
+                // Test each child recursively
+                for(CAddressBookList::iterator iter = mChildren->begin(); iter != mChildren->end(); iter++)
+                        (*iter)->TestDisconnectCache();
+        }
+
+        // See if it exists locally
+        if (IsAdbk())
+                SetFlags(eIsCached, mProtocol->TestAdbk(this));
 }
 
 #pragma mark ____________________________Opening/Closing
 
-void CAddressBook::SetName(const char* name)
+void CAddressBook::SetName(const cdstring& name)
 {
         // Remove from manager's cache
-        if (mAdbkName.length())
+        if (mName.length())
                 CAddressBookManager::sAddressBookManager->SyncAddressBook(this, false);
 
-        mAdbkName = name;
-        CAddressBookManager::sAddressBookManager->RefreshAddressBook(this);
+        mName = name;
+        SetShortName();
+        //CAddressBookManager::sAddressBookManager->RefreshAddressBook(this);
 
         // Add to manager's cache
@@ -93 +506 @@
 }
 
-// New visual address book on source
-void CAddressBook::New()
-{
-        SetFlags(eOpen);
-}
-
 // Open visual address book from source
 void CAddressBook::Open()
 {
+        // Bump reference count and open only if not already done
+        if (!OpenCount())
+                return;
+
+        try
+        {
+                // NB We might have a vCard adbk if we've done searches whilst the address book is closed.
+                // If that is the case we want to discard everything and start from scratch.
+                if (mVCardAdbk != NULL)
+                        mVCardAdbk->Clear();
+                else
+                        mVCardAdbk = new vCard::CVCardAddressBook();
+
+                // Must remove any cached address lookups
+                mAddresses.clear();
+                mGroups.clear();
+
+                // Now open
+                mProtocol->OpenAdbk(this);
+
+                // Mark as open
         SetFlags(eOpen);
-
-        // Remove any cached addresses
-        //mAddresses.erase_all();
-        //mGroups.erase_all();
-}
-
-// Read in addresses
-void CAddressBook::Read()
-{
-        SetFlags(eLoaded);
-}
-
-// Save addresses
-void CAddressBook::Save()
-{
+        }
+        catch (...)
+        {
+                CLOG_LOGCATCH(...);
+                
+                delete mVCardAdbk;
+                mVCardAdbk = NULL;
+        }
 }
 
@@ -127 +548 @@
                 return;
 
+        // Bump reference count and close only if not open elsewhere
+        if (!CloseCount())
+                return;
+
+        mProtocol->CloseAdbk(this);
+
         // Clean up the UI
         CMailControl::AddressBookClosed(this);
 
         SetFlags(eOpen, false);
-        SetFlags(eLoaded, false);
-        
-        Clear();
+        
+        ClearContents();
+
+        delete mVCardAdbk;
+        mVCardAdbk = NULL;
 }
 
@@ -139 +568 @@
 void CAddressBook::Rename(cdstring& new_name)
 {
+        mProtocol->RenameAdbk(this, new_name);
+
         // Remove from manager's cache
         CAddressBookManager::sAddressBookManager->SyncAddressBook(this, false);
@@ -145 +576 @@
         CPreferences::sPrefs->ChangeAddressBookSearch(this, false);
 
-        mAdbkName = new_name;
+        mName = new_name;
 
         // Add to manager's cache
@@ -155 +586 @@
 
 // Clear addresses
-void CAddressBook::Clear()
+void CAddressBook::ClearContents()
 {
         mAddresses.clear();
         mGroups.clear();
+        if (mVCardAdbk != NULL)
+                mVCardAdbk->Clear();
 }
 
@@ -172 +605 @@
         CPreferences::sPrefs->ChangeAddressBookLookup(this, false);
         CPreferences::sPrefs->ChangeAddressBookSearch(this, false);
+
+        // Now delete on server
+        mProtocol->DeleteAdbk(this);
+
+        // Remove from manager
+        //CAddressBookManager::sAddressBookManager->RemoveAddressBook(this);
 }
 
@@ -177 +616 @@
 void CAddressBook::Empty()
 {
-        Clear();
-}
-
+        // Delete and recreate
+        mProtocol->DeleteAdbk(this);
+        mProtocol->CreateAdbk(this);
+        
+        ClearContents();
+}
+
+// Synchronise to local
+void CAddressBook::Synchronise(bool fast)
+{
+        // Tell protocol to synchronise it
+        mProtocol->SynchroniseRemote(this, fast);
+}
+
+// Clear disconnected cache
+void CAddressBook::ClearDisconnect()
+{
+        mProtocol->ClearDisconnect(this);
+}
+
+#ifdef _TODO
 // Copy addresses and groups to another address book
 void CAddressBook::CopyAll(CAddressBook* adbk)
@@ -201 +658 @@
 void CAddressBook::Synchronise(bool fast)
 {
+        // Tell protocol to synchronise it
+        mProtocol->SynchroniseRemote(this, fast);
 }
 
@@ -206 +665 @@
 void CAddressBook::ClearDisconnect()
 {
+        mProtocol->ClearDisconnect(this);
 }
 
@@ -211 +671 @@
 void CAddressBook::SwitchDisconnect(CAdbkProtocol* local)
 {
-}
+        // See if going into disconnected mode (i.e. local != NULL)
+        if (local)
+        {
+                // Set local flag
+                SetFlags(CAddressBook::eLocalAdbk);
+
+                // See if it exists locally
+                if (local->TestAdbk(this))
+                        SetFlags(CAddressBook::eCachedAdbk);
+        }
+        else
+                // Remove disconnected flags
+                SetFlags(static_cast<CAddressBook::EFlags>(CAddressBook::eLocalAdbk | CAddressBook::eCachedAdbk), false);
+}
+#endif
 
 CAdbkAddress* CAddressBook::FindAddress(const char* name)
@@ -278 +752 @@
 void CAddressBook::AddAddress(CAddressList* addrs, bool sorted)
 {
+        // Always update the internal cache and map the address to a vCard
         for(CAddressList::const_iterator iter = addrs->begin(); iter != addrs->end(); iter++)
         {
-                if (IsLoaded())
-                {
+                if (IsOpen())
+                {
+                        // Update internal cache
                         if (sorted)
                                 mAddresses.push_back_sorted(*iter);
                         else
                                 mAddresses.push_back(*iter);
-                }
-                else
+                        
+                        // Map to vCard
+                        auto_ptr<vCard::CVCardVCard> vcard(vcardstore::GenerateVCard(GetVCardAdbk()->GetRef(), static_cast<CAdbkAddress*>(*iter), true));
+                        GetVCardAdbk()->AddNewVCard(vcard.release());
+                }
+        }
+
+        mProtocol->AddAddress(this, addrs);
+
+        // Do change notification
+        CMailControl::AddressAdded(this, addrs);
+
+        // Awlays delete data if not needed
+        for(CAddressList::const_iterator iter = addrs->begin(); iter != addrs->end(); iter++)
+        {
+                if (!IsOpen())
                         delete *iter;
         }
@@ -295 +785 @@
 void CAddressBook::AddUniqueAddresses(CAddressList& add)
 {
-