Trabajando con Carpetas en Exchange Server

Listando todas las Carpetas desde el Servidor

La API Aspose.Email proporciona la capacidad de conectarse al Exchange Server y listar todas las carpetas y subcarpetas. También puedes recuperar todas las subcarpetas de cada carpeta de forma recursiva. También proporciona la capacidad de enumerar carpetas con paginación desde el cliente de Exchange utilizando Exchange Web Service (EWS). Este artículo muestra cómo recuperar todas las subcarpetas desde el servidor de Exchange y recuperar carpetas con paginación.

El siguiente fragmento de código muestra cómo listar carpetas desde Exchange Server.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
void ListSubFolders(System::SharedPtr<Aspose::Email::Clients::Exchange::WebService::IEWSClient> client, System::SharedPtr<Aspose::Email::Clients::Exchange::ExchangeFolderInfo> folderInfo)
{
    // Create the folder in disk (same name as on IMAP server)
    System::Console::WriteLine(folderInfo->get_DisplayName());
    try
    {
        // If this folder has sub-folders, call this method recursively to get messages
        System::SharedPtr<ExchangeFolderInfoCollection> folderInfoCollection = client->ListSubFolders(folderInfo->get_Uri());
        for (auto subfolderInfo : System::IterateOver(folderInfoCollection))
        {
            ListSubFolders(client, subfolderInfo);
        }
    }
    catch (System::Exception& ) { }

}

void ListFoldersFromExchangeServer()
{
    try
    {
        System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());
        System::Console::WriteLine(u"Downloading all messages from Inbox....");
        
        System::SharedPtr<ExchangeMailboxInfo> mailboxInfo = client->GetMailboxInfo();
        System::Console::WriteLine(System::String(u"Mailbox URI: ") + mailboxInfo->get_MailboxUri());
        System::String rootUri = client->GetMailboxInfo()->get_RootUri();
        // List all the folders from Exchange server
        System::SharedPtr<ExchangeFolderInfoCollection> folderInfoCollection = client->ListSubFolders(rootUri);
        for (auto folderInfo : System::IterateOver(folderInfoCollection))
        {
            // Call the recursive method to read messages and get sub-folders
            ListSubFolders(client, folderInfo);
        }
        
        System::Console::WriteLine(u"All messages downloaded.");
    }
    catch (System::Exception& ex)
    {
        System::Console::WriteLine(ex.get_Message());
    }
    
}

Obtener Información del Tipo de Carpeta usando EWS

El enumerador ExchangeFolderType proporcionado por la clase ExchangeFolderInfo se puede utilizar para obtener información sobre el tipo de carpeta. Esto se muestra en el siguiente ejemplo de código.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
const System::String mailboxUri = u"https://exchange/ews/exchange.asmx";
const System::String domain = u"";
const System::String username = u"[e-mail]";
const System::String password = u"password";
System::SharedPtr<System::Net::NetworkCredential> credentials = System::MakeObject<System::Net::NetworkCredential>(username, password, domain);

System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());
    
System::SharedPtr<ExchangeFolderInfoCollection> folderInfoCol = client->ListSubFolders(client->get_MailboxInfo()->get_RootUri());
for (auto folderInfo : System::IterateOver(folderInfoCol))
{
    switch (folderInfo->get_FolderType())
    {
        case Aspose::Email::Clients::Exchange::ExchangeFolderType::Appointment:
            break;
        
        case Aspose::Email::Clients::Exchange::ExchangeFolderType::Contact:
            break;
        
        case Aspose::Email::Clients::Exchange::ExchangeFolderType::Task:
            break;
        
        case Aspose::Email::Clients::Exchange::ExchangeFolderType::Note:
            break;
        
        case Aspose::Email::Clients::Exchange::ExchangeFolderType::StickyNote:
            break;
        
        case Aspose::Email::Clients::Exchange::ExchangeFolderType::Journal:
            break;
        
        default: 
            break;
        
    }
}

Enumerando Carpetas con Soporte de Paginación usando EWS

El siguiente fragmento de código muestra cómo usar el soporte de paginación con EWS.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
try
{
    // Create instance of ExchangeWebServiceClient class by giving credentials
    System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());
    
    // Call ListMessages method to list messages info from Inbox
    System::SharedPtr<ExchangeMessageInfoCollection> msgCollection = client->ListMessages(client->GetMailboxInfo()->get_InboxUri());
    int32_t itemsPerPage = 5;
    System::SharedPtr<System::Collections::Generic::List<System::SharedPtr<PageInfo>>> pages = System::MakeObject<System::Collections::Generic::List<System::SharedPtr<PageInfo>>>();
    System::SharedPtr<PageInfo> pagedMessageInfoCol = client->ListMessagesByPage(client->get_MailboxInfo()->get_InboxUri(), itemsPerPage);
    pages->Add(pagedMessageInfoCol);
    while (!pagedMessageInfoCol->get_LastPage())
    {
        pagedMessageInfoCol = client->ListMessagesByPage(client->get_MailboxInfo()->get_InboxUri(), itemsPerPage);
        pages->Add(pagedMessageInfoCol);
    }
    pagedMessageInfoCol = client->ListMessagesByPage(client->get_MailboxInfo()->get_InboxUri(), itemsPerPage);
    while (!pagedMessageInfoCol->get_LastPage())
    {
        client->ListMessages(client->get_MailboxInfo()->get_InboxUri());
    }
}
catch (System::Exception& ex)
{
    System::Console::Write(ex.get_Message());
}

Accediendo a Carpetas Personalizadas o Subcarpetas del Buzón

IEWSClient permite a los desarrolladores acceder a cualquier carpeta personalizada o subcarpeta del buzón. El método FolderExists() de IEWSClient devuelve la URI de una carpeta/subcarpeta personalizada especificada, que puede usarse para acceder a la carpeta objetivo. En el siguiente ejemplo, se accede a una carpeta personalizada llamada “TestInbox”, que se creó bajo INBOX, y se muestran todos los mensajes de esta carpeta personalizada. Para realizar esta tarea, se llevan a cabo los siguientes pasos:

1. Inicializa el objeto IEWSClient proporcionando credenciales válidas.
2. Accede al buzón predeterminado.
3. Accede a la carpeta principal, que en este ejemplo es INBOX. Esta carpeta principal también puede ser una carpeta personalizada.
4. Utiliza el método FolderExists() para buscar la subcarpeta personalizada especificada, por ejemplo, “TestInbox”. Esto devolverá la URI de “TestInbox”.
5. Utiliza esta URI para acceder a todos los mensajes en esa carpeta personalizada.

El siguiente fragmento de código muestra cómo acceder a carpetas personalizadas o subcarpetas del buzón con EWS.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
// Create instance of EWSClient class by giving credentials
System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());
    
// Create ExchangeMailboxInfo, ExchangeMessageInfoCollection instance
System::SharedPtr<ExchangeMailboxInfo> mailbox = client->GetMailboxInfo();
System::SharedPtr<ExchangeMessageInfoCollection> messages;
System::SharedPtr<ExchangeFolderInfo> subfolderInfo = System::MakeObject<ExchangeFolderInfo>();
    
// Check if specified custom folder exisits and Get all the messages info from the target Uri
client->FolderExists(mailbox->get_InboxUri(), u"TestInbox", subfolderInfo);
    
//if custom folder exists
if (subfolderInfo != nullptr)
{
    messages = client->ListMessages(subfolderInfo->get_Uri());
    
    // Parse all the messages info collection
    for (auto info : System::IterateOver(messages))
    {
        System::String strMessageURI = info->get_UniqueUri();
        // now get the message details using FetchMessage()
        System::SharedPtr<MailMessage> msg = client->FetchMessage(strMessageURI);
        System::Console::WriteLine(System::String(u"Subject: ") + msg->get_Subject());
    }
}
else
{
    System::Console::WriteLine(u"No folder with this name found.");
}

Listando Carpetas Públicas

Microsoft Exchange Server permite a los usuarios crear carpetas públicas y publicar mensajes en ellas. Para hacer esto a través de tu aplicación, utiliza la clase EWSClient para conectarte al Exchange Server y leer y descargar mensajes y publicaciones de carpetas públicas. El siguiente fragmento de código muestra cómo leer todas las carpetas y subcarpetas públicas, y listar y descargar cualquier mensaje encontrado en estas carpetas. Este ejemplo solo funciona con Microsoft Exchange Server 2007 o superior, ya que solo estos son compatibles con EWS.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
static String dataDir = GetDataDir_Exchange();
String username;
String password;
String domain;
String mailboxUri;

void ListMessagesFromSubFolder(System::SharedPtr<Aspose::Email::Clients::Exchange::ExchangeFolderInfo> publicFolder, System::SharedPtr<Aspose::Email::Clients::Exchange::WebService::IEWSClient> client)
{
    System::Console::WriteLine(System::String(u"Folder Name: ") + publicFolder->get_DisplayName());
    System::SharedPtr<ExchangeMessageInfoCollection> msgInfoCollection = client->ListMessagesFromPublicFolder(publicFolder);
    for (auto messageInfo : System::IterateOver(msgInfoCollection))
    {
        System::SharedPtr<MailMessage> msg = client->FetchMessage(messageInfo->get_UniqueUri());
        System::Console::WriteLine(msg->get_Subject());
        msg->Save(dataDir + msg->get_Subject() + u".msg", SaveOptions::get_DefaultMsgUnicode());
    }

    // Call this method recursively for any subfolders
    if (publicFolder->get_ChildFolderCount() > 0)
    {
        System::SharedPtr<ExchangeFolderInfoCollection> subfolders = client->ListSubFolders(publicFolder);
        for (System::SharedPtr<Aspose::Email::Clients::Exchange::ExchangeFolderInfo> subfolder : System::IterateOver(subfolders))
        {
            ListMessagesFromSubFolder(subfolder, client);
        }
    }
}

void ReadPublicFolders()
{
    System::SharedPtr<System::Net::NetworkCredential> credential = System::MakeObject<System::Net::NetworkCredential>(username, password, domain);
    System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());

    System::SharedPtr<ExchangeFolderInfoCollection> folders = client->ListPublicFolders();
    for (auto publicFolder : System::IterateOver(folders))
    {
        System::Console::WriteLine(System::String(u"Name: ") + publicFolder->get_DisplayName());
        System::Console::WriteLine(System::String(u"Subfolders count: ") + publicFolder->get_ChildFolderCount());
        ListMessagesFromSubFolder(publicFolder, client);

    }
}

void DownloadMessagesFromPublicFolders()
{
    try
    {
        ReadPublicFolders();
    }
    catch (System::Exception& ex)
    {
        System::Console::WriteLine(ex.get_Message());
    }
    
}

Sincronizando Elementos de Carpeta

La API Aspose.Email de IEWSClient proporciona la característica de sincronizar una carpeta de Exchange para su contenido. El método SyncFolder expuesto por la clase IEWSClient se puede utilizar para sincronizar la información de la carpeta en una carpeta especificada. El siguiente fragmento de código muestra cómo sincronizar la información de la carpeta de Exchange.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());
System::SharedPtr<MailMessage> message1 = System::MakeObject<MailMessage>(u"[e-mail]", u"[e-mail]", System::String(u"EMAILNET-34738 - ") + System::ObjectExt::ToString(System::Guid::NewGuid()), u"EMAILNET-34738 Sync Folder Items");
client->Send(message1);
        
System::SharedPtr<MailMessage> message2 = System::MakeObject<MailMessage>(u"[e-mail]", u"[e-mail]", System::String(u"EMAILNET-34738 - ") + System::ObjectExt::ToString(System::Guid::NewGuid()), u"EMAILNET-34738 Sync Folder Items");
client->Send(message2);
        
System::SharedPtr<ExchangeMessageInfoCollection> messageInfoCol = client->ListMessages(client->get_MailboxInfo()->get_InboxUri());
System::SharedPtr<SyncFolderResult> result = client->SyncFolder(client->get_MailboxInfo()->get_InboxUri(), nullptr);
System::Console::WriteLine(result->get_NewItems()->get_Count());
System::Console::WriteLine(result->get_ChangedItems()->get_Count());
System::Console::WriteLine(result->get_ReadFlagChanged()->get_Count());
System::Console::WriteLine(result->get_DeletedItems()->get_Length());

Recuperando Permisos para Carpetas de Exchange

Se asignan permisos a los usuarios para las carpetas públicas en Exchange Server, lo que limita/determina el nivel de acceso que un usuario tiene a estas carpetas. La clase ExchangeFolderPermission proporciona un conjunto de propiedades de permiso para las carpetas de Exchange, como el nivel de permiso, si pueden crear elementos, eliminar elementos, y realizar otras tareas según lo especificado por las propiedades de permiso. Los permisos se pueden recuperar usando el método GetFolderPermissions() de IEWSClient. Este artículo muestra cómo recuperar los permisos aplicados a una carpeta pública para todos los usuarios que tienen acceso a las carpetas compartidas.

Para realizar esta tarea:

1. Inicializa el IEWSClient.
2. Usa el ListPublicFolders para obtener una lista de todas las carpetas públicas.
3. Recupera los permisos asociados con una carpeta usando el método GetFolderPermissions().

El siguiente fragmento de código muestra cómo usar la clase IEWSClient para recuperar los permisos aplicados a una carpeta.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
System::String folderName = u"DesiredFolderName";
    
// Create instance of EWSClient class by giving credentials
System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());

try
{
    System::SharedPtr<ExchangeFolderInfoCollection> folders = client->ListPublicFolders();
    System::SharedPtr<ExchangeFolderPermissionCollection> permissions = System::MakeObject<ExchangeFolderPermissionCollection>();

    System::SharedPtr<ExchangeFolderInfo> publicFolder;

    for (auto folderInfo : System::IterateOver(folders))
    {
        if (System::ObjectExt::Equals(folderInfo->get_DisplayName(), folderName))
        {
            publicFolder = folderInfo;
        }
    }

    if (publicFolder == nullptr)
    {
        System::Console::WriteLine(u"public folder was not created in the root public folder");
    }

    System::SharedPtr<ExchangePermissionCollection> folderPermissionCol = client->GetFolderPermissions(publicFolder->get_Uri());
    for (auto perm : System::IterateOver(folderPermissionCol))
    {
        System::SharedPtr<ExchangeFolderPermission> permission = System::DynamicCast_noexcept<Aspose::Email::Clients::Exchange::ExchangeFolderPermission>(perm);
        if (permission == nullptr)
        {
            System::Console::WriteLine(u"Permission is null.");
        }
        else
        {
            System::Console::WriteLine(u"User's primary smtp address: {0}", System::ObjectExt::Box<System::String>(permission->get_UserInfo()->get_PrimarySmtpAddress()));
            System::Console::WriteLine(u"User can create Items: {0}", System::ObjectExt::Box<System::String>(System::Convert::ToString(permission->get_CanCreateItems())));
            System::Console::WriteLine(u"User can delete Items: {0}", System::ObjectExt::Box<System::String>(System::ObjectExt::ToString(permission->get_DeleteItems())));
            System::Console::WriteLine(u"Is Folder Visible: {0}", System::ObjectExt::Box<System::String>(System::Convert::ToString(permission->get_IsFolderVisible())));
            System::Console::WriteLine(u"Is User owner of this folder: {0}", System::ObjectExt::Box<System::String>(System::Convert::ToString(permission->get_IsFolderOwner())));
            System::Console::WriteLine(u"User can read items: {0}", System::ObjectExt::Box<System::String>(System::ObjectExt::ToString(permission->get_ReadItems())));
        }
    }
    System::SharedPtr<ExchangeMailboxInfo> mailboxInfo = client->GetMailboxInfo();
    //Get the Permissions for the Contacts and Calendar Folder
    System::SharedPtr<ExchangePermissionCollection> contactsPermissionCol = client->GetFolderPermissions(mailboxInfo->get_ContactsUri());
    System::SharedPtr<ExchangePermissionCollection> calendarPermissionCol = client->GetFolderPermissions(mailboxInfo->get_CalendarUri());
}
catch (System::Exception& ex)
{
    System::Console::WriteLine(ex.get_Message());
}

Creando Carpetas y Subcarpetas

La API Aspose.Email proporciona la capacidad de crear carpetas en un buzón de Exchange. El método CreateFolder de IEWSClient se puede utilizar para este propósito. Para crear una carpeta en el buzón del servidor Exchange, se pueden seguir los siguientes pasos.

1. Crea una instancia de IEWSClient.
2. Establece la propiedad set_UseSlashAsFolderSeparator según sea necesario. Si se establece en true, la aplicación considerará la “Barra” como separador de carpetas y la subcarpeta se creará después de la barra.
3. Utiliza el método CreateFolder para crear la carpeta.

El siguiente fragmento de código muestra cómo crear carpetas y subcarpetas.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
// Create instance of EWSClient class by giving credentials
System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());

System::String inbox = client->get_MailboxInfo()->get_InboxUri();
System::String folderName1 = u"EMAILNET-35054";
System::String subFolderName0 = u"2015";
System::String folderName2 = folderName1 + u"/" + subFolderName0;
System::String folderName3 = folderName1 + u" / 2015";
System::SharedPtr<ExchangeFolderInfo> rootFolderInfo;
System::SharedPtr<ExchangeFolderInfo> folderInfo;

client->set_UseSlashAsFolderSeparator(true);
client->CreateFolder(client->get_MailboxInfo()->get_InboxUri(), folderName1);
client->CreateFolder(client->get_MailboxInfo()->get_InboxUri(), folderName2);

if (client->FolderExists(inbox, folderName1, rootFolderInfo))
{
	if (client->FolderExists(inbox, folderName2, folderInfo))
	{
		client->DeleteFolder(folderInfo->get_Uri(), true);
	}
	client->DeleteFolder(rootFolderInfo->get_Uri(), true);
}

Respaldo de Carpetas de Exchange a PST

A menudo sucede que los usuarios pueden querer hacer una copia de seguridad de todas o algunas de las carpetas del buzón. Aspose.Email proporciona la capacidad de hacer una copia de seguridad de todas o de las carpetas de buzón de Exchange especificadas a un PST. Para hacer una copia de seguridad de las carpetas del servidor Exchange, se pueden seguir los siguientes pasos.

1. Crea una instancia de IEWSClient.
2. Agrega la información de las carpetas requeridas a ExchangeFolderInfoCollection.
3. Utiliza el método IEWSClient->Backup para exportar el contenido de las carpetas a PST.

El siguiente fragmento de código muestra cómo hacer una copia de seguridad de las carpetas de Exchange a PST.

// For complete examples and data files, please go to https://github.com/aspose-email/Aspose.Email-for-C
System::String dataDir = GetDataDir_Exchange();
// Create instance of IEWSClient class by providing credentials
System::SharedPtr<IEWSClient> client = GetExchangeEWSClient(GetExchangeTestUser());
    
// Get Exchange mailbox info of other email account
System::SharedPtr<ExchangeMailboxInfo> mailboxInfo = client->GetMailboxInfo();
System::SharedPtr<ExchangeFolderInfo> info = client->GetFolderInfo(mailboxInfo->get_InboxUri());
System::SharedPtr<ExchangeFolderInfoCollection> fc = System::MakeObject<ExchangeFolderInfoCollection>();
fc->Add(info);
try 
{
    client->Backup(fc, dataDir + u"Backup_out.pst", Aspose::Email::Storage::Pst::BackupOptions::None);
}
catch (System::Exception& ex)
{
    System::Console::WriteLine(ex.get_Message());
}