libmapi++/folder.h

   1 /*
   2    libmapi C++ Wrapper
   3    Folder Class
   4
   5    Copyright (C) Alan Alvarez 2008.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20
  21 #ifndef LIBMAPIPP__FOLDER_H__
  22 #define LIBMAPIPP__FOLDER_H__
  23
  24 #include <iostream> //for debugging
  25 #include <vector>
  26 #include <boost/shared_ptr.hpp>
  27
  28 #include <libmapi++/clibmapi.h>
  29 #include <libmapi++/mapi_exception.h>
  30 #include <libmapi++/object.h>
  31 #include <libmapi++/message.h>
  32
  33 namespace libmapipp
  34 {
  35
  36 /**
  37  *  This class represents a %folder or container within Exchange
  38  */
  39 class folder : public object {
  40         public:
  41                 /**
  42                  * Pointer to a message
  43                 */
  44                 typedef boost::shared_ptr<message>              message_shared_ptr;
  45
  46                 typedef std::vector<message_shared_ptr >        message_container_type;
  47
  48                 /**
  49                  * Pointer to a %folder
  50                 */
  51                 typedef boost::shared_ptr<folder>               folder_shared_ptr;
  52
  53                 /**
  54                  * Hierarchy folders
  55                  *
  56                  * This is a vector (list) of child folders for a given %folder
  57                 */
  58                 typedef std::vector<folder_shared_ptr>          hierarchy_container_type;
  59
  60                 /**
  61                  * \brief Constructor
  62                  *
  63                  * \param parent_folder The parent of this %folder.
  64                  * \param folder_id     This folder's id.
  65                 */
  66                 folder(object& parent_folder, const mapi_id_t folder_id) throw(mapi_exception)
  67                 : object(parent_folder.get_session(), "folder"), m_id(folder_id)
  68                 {
  69                         if (OpenFolder(&parent_folder.data(), folder_id, &m_object) != MAPI_E_SUCCESS)
  70                                 throw mapi_exception(GetLastError(), "folder::folder : OpenFolder");
  71                 }
  72
  73                 /**
  74                  * \brief Obtain %folder id
  75                  *
  76                  * \return This folder's id.
  77                  */
  78                 mapi_id_t get_id() const { return m_id; }
  79
  80                 /**
  81                  * \brief Delete a message that belongs to this %folder
  82                  *
  83                  * \param message_id The id of the message to delete.
  84                  */
  85                 void delete_message(mapi_id_t message_id) throw (mapi_exception)
  86                 {
  87                         if (DeleteMessage(&m_object, &message_id, 1) != MAPI_E_SUCCESS)
  88                                 throw mapi_exception(GetLastError(), "folder::delete_message : DeleteMessage");
  89                 }
  90
  91                 /**
  92                  * \brief Fetch all messages in this %folder
  93                  *
  94                  * \return A container of message shared pointers.
  95                  */
  96                 message_container_type fetch_messages() throw(mapi_exception)
  97                 {
  98                         uint32_t        contents_table_row_count = 0;
  99                         mapi_object_t   contents_table;
 100
 101                         mapi_object_init(&contents_table);
 102                         if (GetContentsTable(&m_object, &contents_table, 0, &contents_table_row_count) != MAPI_E_SUCCESS) {
 103                                 mapi_object_release(&contents_table);
 104                                 throw mapi_exception(GetLastError(), "folder::fetch_messages : GetContentsTable");
 105                         }
 106
 107                         SPropTagArray* property_tag_array = set_SPropTagArray(m_session.get_memory_ctx(), 0x2, PR_FID,
 108                                                                                                                PR_MID);
 109
 110                         if (SetColumns(&contents_table, property_tag_array) != MAPI_E_SUCCESS) {
 111                                 MAPIFreeBuffer(property_tag_array);
 112                                 mapi_object_release(&contents_table);
 113                                 throw mapi_exception(GetLastError(), "folder::fetch_messages : SetColumns");
 114                         }
 115
 116                         MAPIFreeBuffer(property_tag_array);
 117
 118                         uint32_t rows_to_read = contents_table_row_count;
 119                         SRowSet  row_set;
 120
 121                         message_container_type message_container;
 122                         message_container.reserve(contents_table_row_count);
 123
 124                         while( (QueryRows(&contents_table, rows_to_read, TBL_ADVANCE, &row_set) == MAPI_E_SUCCESS) && row_set.cRows) {
 125                                 rows_to_read -= row_set.cRows;
 126                                 for (unsigned int i = 0; i < row_set.cRows; ++i) {
 127                                         try {
 128                                                 message_container.push_back(message_shared_ptr(new message(m_session,
 129                                                                                                            m_id,
 130                                                                                                            row_set.aRow[i].lpProps[1].value.d)));
 131                                         }
 132                                         catch(mapi_exception e) {
 133                                                 mapi_object_release(&contents_table);
 134                                                 throw;
 135                                         }
 136                                 }
 137                         }
 138
 139                         mapi_object_release(&contents_table);
 140
 141                         return message_container;
 142                 }
 143
 144                 /**
 145                  * \brief Fetch all subfolders within this %folder
 146                  *
 147                  * \return A container of %folder shared pointers.
 148                  */
 149                 hierarchy_container_type fetch_hierarchy() throw(mapi_exception)
 150                 {
 151                         mapi_object_t   hierarchy_table;
 152                         uint32_t        hierarchy_table_row_count = 0;
 153
 154                         mapi_object_init(&hierarchy_table);
 155                         if (GetHierarchyTable(&m_object, &hierarchy_table, 0, &hierarchy_table_row_count) != MAPI_E_SUCCESS) {
 156                                 mapi_object_release(&hierarchy_table);
 157                                 throw mapi_exception(GetLastError(), "folder::fetch_hierarchy : GetHierarchyTable");
 158                         }
 159
 160                         SPropTagArray* property_tag_array = set_SPropTagArray(m_session.get_memory_ctx(), 0x1, PR_FID);
 161
 162                         if (SetColumns(&hierarchy_table, property_tag_array)) {
 163                                 MAPIFreeBuffer(property_tag_array);
 164                                 mapi_object_release(&hierarchy_table);
 165                                 throw mapi_exception(GetLastError(), "folder::fetch_hierarchy : SetColumns");
 166                         }
 167
 168                         MAPIFreeBuffer(property_tag_array);
 169
 170                         uint32_t rows_to_read = hierarchy_table_row_count;
 171                         SRowSet  row_set;
 172
 173                         hierarchy_container_type hierarchy_container;
 174                         hierarchy_container.reserve(hierarchy_table_row_count);
 175
 176                         while( (QueryRows(&hierarchy_table, rows_to_read, TBL_ADVANCE, &row_set) == MAPI_E_SUCCESS) && row_set.cRows) {
 177                                 rows_to_read -= row_set.cRows;
 178                                 for (unsigned int i = 0; i < row_set.cRows; ++i) {
 179                                         try {
 180                                                 hierarchy_container.push_back(folder_shared_ptr(new folder(*this,
 181                                                                                                            row_set.aRow[i].lpProps[0].value.d)));
 182                                         }
 183                                         catch(mapi_exception e) {
 184                                                 mapi_object_release(&hierarchy_table);
 185                                                 throw;
 186                                         }
 187                                 }
 188                         }
 189
 190                         mapi_object_release(&hierarchy_table);
 191
 192                         return hierarchy_container;
 193                 }
 194
 195                 /**
 196                  * Destructor
 197                  */
 198                 virtual ~folder() throw()
 199                 {
 200                 }
 201
 202         private:
 203                 mapi_id_t       m_id;
 204 };
 205
 206 } // namespace libmapipp
 207
 208 #endif //!LIBMAPIPP__FOLDER_H__