Trabalhando com Pastas no Exchange Server

Listando todas as Pastas do Servidor

A API Aspose.Email fornece a capacidade de conectar-se ao Exchange Server e listar todas as pastas e subpastas. Você também pode recuperar todas as subpastas de cada pasta de forma recursiva. Ela também oferece a capacidade de enumerar pastas com paginação do cliente Exchange usando o Exchange Web Service (EWS). Este artigo mostra como recuperar todas as subpastas do servidor Exchange e recuperar pastas com paginação.

O seguinte trecho de código mostra como listar pastas do 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());
    }
    
}

Obter Informações sobre o Tipo de Pasta usando EWS

O enumerador ExchangeFolderType fornecido pela classe ExchangeFolderInfo pode ser usado para obter informações sobre o tipo da pasta. Isso é mostrado no exemplo de código abaixo.

// 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 Pastas com Suporte a Paginação usando EWS

O seguinte trecho de código mostra como usar o suporte à paginação com 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());
}

Acessando Pastas Personalizadas ou Subpastas da Caixa de Correio

IEWSClient permite que os desenvolvedores acessem qualquer pasta personalizada ou subpasta da caixa de correio. O método FolderExists() da classe IEWSClient retorna o URI de uma pasta/sub-pasta personalizada especificada, que pode ser usada para acessar a pasta de destino. No exemplo a seguir, uma pasta personalizada chamada “TestInbox”, que é criada sob a INBOX, é acessada e todas as mensagens são exibidas a partir dessa pasta personalizada. Para realizar essa tarefa, os seguintes passos são realizados:

1. Inicialize o objeto IEWSClient fornecendo credenciais válidas.
2. Acesse a caixa de correio padrão.
3. Acesse a pasta pai, que é a INBOX neste exemplo. Esta pasta pai também pode ser uma pasta personalizada.
4. Use o método FolderExists() para procurar a subpasta personalizada especificada, por exemplo, “TestInbox”. Ele retornará o URI de “TestInbox”.
5. Use esse URI para acessar todas as mensagens daquela pasta personalizada.

O seguinte trecho de código mostra como acessar pastas personalizadas ou subpastas da caixa de correio com 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 Pastas Públicas

O Microsoft Exchange Server permite que os usuários criem pastas públicas e publiquem mensagens nelas. Para fazer isso através de seu aplicativo, use a classe EWSClient para conectar-se ao Exchange Server e ler e baixar mensagens e postagens de pastas públicas. O seguinte trecho de código mostra como ler todas as pastas públicas e subpastas, e listar e fazer o download de quaisquer mensagens encontradas nessas pastas. Este exemplo só funciona com o Microsoft Exchange Server 2007 ou superior, já que somente esses suportam 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 Itens de Pasta

A API Aspose.Email do IEWSClient fornece a funcionalidade de sincronizar uma pasta Exchange para seu conteúdo. O método SyncFolder exposto pela classe IEWSClient pode ser usado para sincronizar informações de uma pasta especificada. O seguinte trecho de código mostra como sincronizar informações da pasta 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 Permissões para Pastas do Exchange

Os usuários são atribuídos permissões a pastas públicas no Exchange Server, que limitam/determinam o nível de acesso que um usuário tem a essas pastas. A classe ExchangeFolderPermission fornece um conjunto de propriedades de permissão para pastas Exchange, como o nível de permissão, se podem criar itens, deletar itens, e realizar outras tarefas conforme especificado pelas propriedades de permissão. As permissões podem ser recuperadas usando o método GetFolderPermissions() da classe IEWSClient. Este artigo mostra como recuperar as permissões aplicadas a uma pasta pública para todos os usuários que têm acesso às pastas compartilhadas.

Para realizar essa tarefa:

1. Inicialize o IEWSClient.
2. Use o ListPublicFolders para obter uma lista de todas as pastas públicas.
3. Recupere as permissões associadas a uma pasta usando o método GetFolderPermissions().

O seguinte trecho de código mostra como usar a classe IEWSClient para recuperar permissões aplicadas a uma pasta.

// 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());
}

Criando Pastas e Sub-Pastas

A API Aspose.Email fornece a capacidade de criar pastas em uma caixa de correio Exchange. O método CreateFolder da classe IEWSClient pode ser usado para esse fim. Para criar uma pasta na caixa de correio do servidor Exchange, os seguintes passos podem ser seguidos.

1. Crie uma instância de IEWSClient.
2. Defina a propriedade set_UseSlashAsFolderSeparator como necessário. Se definida como true, a aplicação considerar “Barra” como separador de pasta e a subpasta será criada após a barra.
3. Use o método CreateFolder para criar a pasta.

O seguinte trecho de código mostra como criar pastas e sub-pastas.

// 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);
}

Fazendo Backup de Pastas do Exchange para PST

Muitas vezes, os usuários podem querer fazer um backup de todas ou algumas das pastas da caixa de correio. A Aspose.Email fornece a capacidade de fazer um backup de todas ou pastas de caixa de correio Exchange especificadas para um PST. Para fazer um backup das pastas do servidor Exchange, os seguintes passos podem ser seguidos.

1. Crie uma instância de IEWSClient.
2. Adicione as informações da pasta necessária ao ExchangeFolderInfoCollection.
3. Use o método IEWSClient->Backup para exportar o conteúdo da pasta para PST.

O seguinte trecho de código mostra como fazer backup de pastas do Exchange para 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());
}