Get rooms

examples/get_rooms.cpp

@@ -0,0 +1,72 @@
+
+//   Copyright 2018 otris software AG
+//
+//   Licensed under the Apache License, Version 2.0 (the "License");
+//   you may not use this file except in compliance with the License.
+//   You may obtain a copy of the License at
+//
+//       http://www.apache.org/licenses/LICENSE-2.0
+//
+//   Unless required by applicable law or agreed to in writing, software
+//   distributed under the License is distributed on an "AS IS" BASIS,
+//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//   See the License for the specific language governing permissions and
+//   limitations under the License.
+
+#include <ews/ews.hpp>
+#include <ews/ews_test_support.hpp>
+#include <exception>
+#include <iostream>
+#include <ostream>
+#include <stdlib.h>
+#include <string>
+
+int main()
+{
+    int res = EXIT_SUCCESS;
+    ews::set_up();
+
+    try
+    {
+        const auto env = ews::test::environment();
+        auto service = ews::service(env.server_uri, env.domain, env.username,
+                                    env.password);
+
+        auto room_lists = service.get_room_lists();
+        if (room_lists.empty())
+        {
+            std::cout << "There are no room lists configured\n";
+        } 
+        else
+        {   
+            for (const auto& room_list : room_lists)
+            {
+                std::cout << "The room list " 
+                          << room_list.name()
+                          << " contains the following rooms:\n";
+                auto rooms = service.get_rooms(room_list);
+                if (rooms.empty())
+                {
+                    std::cout << "This room list does not contain any rooms\n";
+                }
+                else
+                {
+                    for (const auto& room : rooms)
+                    {
+                        std::cout << room.name() << "\n";
+                    }
+                }
+            }
+        }
+    }
+    catch (std::exception& exc)
+    {
+        std::cout << exc.what() << std::endl;
+        res = EXIT_FAILURE;
+    }
+
+    ews::tear_down();
+    return res;
+}
+
+// vim:et ts=4 sw=4

include/ews/ews.hpp

@@ -10141,6 +10141,38 @@ namespace internal
         std::vector<response_message> messages_;
     };
 
+    class get_room_lists_response_message final
+        : public response_message_with_items<mailbox>
+    {
+    public:
+        // implemented below
+        static get_room_lists_response_message parse(http_response&&);
+
+    private:
+        get_room_lists_response_message(response_result&& res,
+                                        std::vector<mailbox>&& items)
+            : response_message_with_items<mailbox>(std::move(res),
+                                                   std::move(items))
+        {
+        }
+    };
+
+    class get_rooms_response_message final
+        : public response_message_with_items<mailbox>
+    {
+    public:
+        // implemented below
+        static get_rooms_response_message parse(http_response&&);
+
+    private:
+        get_rooms_response_message(response_result&& res,
+            std::vector<mailbox>&& items)
+            : response_message_with_items<mailbox>(std::move(res),
+                std::move(items))
+        {
+        }
+    };
+
     template <typename ItemType>
     class get_item_response_message final
         : public response_message_with_items<ItemType>
@@ -18690,6 +18722,43 @@ class basic_service final
         return *this;
     }
 
+    //! Gets all room lists in the Exchange store.
+    std::vector<mailbox> get_room_lists()
+    {
+        std::string msg = "<m:GetRoomLists />";
+        auto response = request(msg);
+        const auto response_message =
+            internal::get_room_lists_response_message::parse(
+                std::move(response));
+        if (!response_message.success())
+        {
+            throw exchange_error(response_message.result());
+        }
+        return response_message.items();
+    }
+
+    //! Gets all rooms from a room list in the Exchange store.
+    std::vector<mailbox> get_rooms(const mailbox& room_list)
+    {
+        std::stringstream sstr;
+        sstr << "<m:GetRooms>"
+            "<m:RoomList>"
+            "<t:EmailAddress>"
+            << room_list.value()
+            << "</t:EmailAddress>"
+            "</m:RoomList>"
+            "</m:GetRooms>";
+
+        auto response = request(sstr.str());
+        const auto response_message =
+            internal::get_rooms_response_message::parse(std::move(response));
+        if (!response_message.success())
+        {
+            throw exchange_error(response_message.result());
+        }
+        return response_message.items();
+    }
+
     //! Synchronizes a folder in the Exchange store.
     sync_folder_items_result sync_folder_items(const folder_id& folder_id,
                                                int max_changes_returned = 512)
@@ -20891,6 +20960,61 @@ namespace internal
         return get_folder_response_message(std::move(result), std::move(items));
     }
 
+    inline get_room_lists_response_message
+    get_room_lists_response_message::parse(http_response&& response)
+    {
+        const auto doc = parse_response(std::move(response));
+        auto elem = get_element_by_qname(*doc, "GetRoomListsResponse",
+                                         uri<>::microsoft::messages());
+
+        EWS_ASSERT(elem &&
+                   "Expected <GetRoomListsResponse>, got nullptr");
+        auto result = parse_response_class_and_code(*elem);
+        auto room_lists = std::vector<mailbox>();
+        auto items_elem =
+            elem->first_node_ns(uri<>::microsoft::messages(), "RoomLists");
+        EWS_ASSERT(items_elem && "Expected <RoomLists> element");
+
+        for_each_child_node(
+            *items_elem, [&room_lists](const rapidxml::xml_node<>& item_elem)
+        {
+            room_lists.emplace_back(mailbox::from_xml_element(item_elem));
+        });
+        return get_room_lists_response_message(std::move(result),
+                                               std::move(room_lists));
+    }
+
+    inline get_rooms_response_message
+        get_rooms_response_message::parse(http_response&& response)
+    {
+        const auto doc = parse_response(std::move(response));
+        auto elem = get_element_by_qname(*doc, "GetRoomsResponse",
+                                         uri<>::microsoft::messages());
+
+        EWS_ASSERT(elem &&
+                   "Expected <GetRoomsResponse>, got nullptr");
+        auto result = parse_response_class_and_code(*elem);
+        auto rooms = std::vector<mailbox>();
+        auto items_elem =
+            elem->first_node_ns(uri<>::microsoft::messages(), "Rooms");
+        if (!items_elem)
+        {
+            return get_rooms_response_message(std::move(result),
+                                              std::move(rooms));
+        }
+
+        for_each_child_node(
+            *items_elem, [&rooms](const rapidxml::xml_node<>& item_elem)
+        {
+            auto room_elem = item_elem.first_node_ns(uri<>::microsoft::types(),
+                                                     "Id");
+            EWS_ASSERT(room_elem && "Expected <Id> element");
+            rooms.emplace_back(mailbox::from_xml_element(*room_elem));
+        });
+        return get_rooms_response_message(std::move(result),
+                                          std::move(rooms));
+    }
+
     inline folder_response_message
     folder_response_message::parse(http_response&& response)
     {