Documentation – Práce s OLM soubory

Net: Otevírání OLM souborů

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Email pro .NET představuje soubor úložiště Outlook for Mac pomocí OlmStorage třída. Tento článek ukazuje, jak otevřít soubor OLM z cesty nebo streamu a jak bezpečně načíst soubor, který může být poškozený.

Otevřít soubor OLM

Soubor OLM lze otevřít dvěma způsoby:

použití konstruktoru;
použití statické FromFile metoda.

Mezi těmito dvěma přístupy existuje rozdíl v chování, který ovlivňuje, jak je inicializována hierarchie složek. Viz Navigace v OLM složkách pro podrobnosti.

Použití konstruktoru

Pro otevření souboru zavolejte konstruktor OlmStorage třídu a předat úplný název souboru jako argument. Protože OlmStorage implementuje IDisposable, obalte jej do using instrukci tak, aby podkladové file‑handlové bylo uvolněno po dokončení.

var fileName = "MyStorage.olm";
using (var olm = new OlmStorage(fileName))
{
    // work with the storage
}

Použití statické metody FromFile

Pro otevření souboru použijte statickou FromFile metody a předat úplný název souboru jako argument:

var fileName = "MyStorage.olm";
using (var olm = OlmStorage.FromFile(fileName))
{
    // work with the storage
}

Otevřít soubor OLM ze streamu

Když data OLM nepocházejí z lokální cesty – například jsou získána z databáze, síťového zdroje nebo cloudového úložiště – můžete je otevřít přímo ze Stream. Použijte OlmStorage(Stream) konstruktor nebo statická FromStream metoda.

using (var stream = File.OpenRead("MyStorage.olm"))
using (var olm = new OlmStorage(stream))
{
    // work with the storage
}

Statická metoda funguje stejným způsobem:

using (var stream = File.OpenRead("MyStorage.olm"))
using (var olm = OlmStorage.FromStream(stream))
{
    // work with the storage
}

Udržujte zdrojový stream otevřený po celou dobu, dokud přistupujete k úložišti. Uzavření streamu před dokončením čtení složek a zpráv způsobí chyby při čtení.

Otevřít poškozený soubor OLM

Pokud může být soubor částečně poškozený, můžete stále extrahovat co nejvíce dat bez zastavení při první chybě. K tomu vytvořte OlmStorage instance s OlmStorage(TraversalExceptionsCallback callback) konstruktora, pak načtěte soubor pomocí Load namísto FromFile.

Zpětné volání přijímá výjimky vyvolané během načítání a procházení, takže je můžete zaznamenat nebo ignorovat. Metoda Load metoda vrací true pokud byl soubor načten úspěšně a procházení je možné, a false pokud je soubor příliš poškozený pro procházení.

using (var olm = new OlmStorage((exception, id) =>
{
    // Exception handling code.
    Console.WriteLine($"Failed to process item '{id}': {exception.Message}");
}))
{
    if (olm.Load(fileName))
    {
        // The file was loaded and can be traversed.
        var folderHierarchy = olm.GetFolders();
    }
    else
    {
        Console.WriteLine("The OLM file is corrupted and cannot be traversed.");
    }
}

Pro kompletní příklad extrakce položek z poškozeného souboru viz Čtení a extrakce OLM zpráv.

Net: Navigace v OLM složkách

Mon, 01 Jan 0001 00:00:00 +0000

OLM soubor organizuje svá data do stromu složek, z nichž každá je reprezentována OlmFolder objekt. Tento článek ukazuje, jak procházet hierarchii složek, získat konkrétní složku podle názvu, navigovat pod‑složky a číst cesty složek.

Získat hierarchii složek

Jakmile je soubor otevřen, přistupujte k jeho adresářové struktuře přes FolderHierarchy vlastnosti. Tato vlastnost vrací seznam OlmFolder objekty, z nichž každý představuje adresář nejvyšší úrovně v OLM souboru. Pro hlubší průzkum čtěte SubFolders vlastnost každé složky, která vrací její podadresáře. Pomocí těchto dvou členů můžete projít celou hierarchii.

Níže uvedený příklad vytiskne všechny složky v hierarchickém pořadí:

using (var olm = new OlmStorage(fileName))
{
    PrintAllFolders(olm.FolderHierarchy, string.Empty);
}

private void PrintAllFolders(IEnumerable<OlmFolder> folderHierarchy, string indent)
{
    foreach (var folder in folderHierarchy)
    {
        Console.WriteLine($"{indent}{folder.Name}");
        PrintAllFolders(folder.SubFolders, indent + "-");
    }
}

FolderHierarchy a metoda FromFile

Způsob, jakým soubor otevřete, ovlivňuje jak FolderHierarchy se chová:

Když otevřete soubor pomocí konstruktoru, FolderHierarchy vlastnost se inicializuje automaticky.
Když otevřete soubor pomocí FromFile metoda, FolderHierarchy není standardně inicializována a vrací null. V tomto případě zavolejte GetFolders metodu explicitně k inicializaci hierarchie a získání seznamu adresářů:

using (var olm = OlmStorage.FromFile(fileName))
{
    var folders = olm.GetFolders();
}

Získat složku podle názvu

Pro získání jedné složky podle názvu zavolejte GetFolder metoda. Předávejte název složky jako první argument a boolean jako druhý argument, který určuje, zda má být při hledání rozlišení velikosti písmen ignorováno.

using (var olm = OlmStorage.FromFile(fileName))
{
    // get the Inbox folder by name, ignoring case
    OlmFolder folder = olm.GetFolder("Inbox", true);
}

Získat pod‑složku podle názvu

Každý OlmFolder také vám umožní najít podřízenou složku přímo pomocí GetSubFolder metody. Předávejte název pod‑složky a zda má být rozdíl mezi velkými a malými písmeny ignorován. To je užitečné, když již máte nadřazenou složku a chcete pokračovat bez opětovného skenování celé hierarchie.

using (var olm = OlmStorage.FromFile(fileName))
{
    OlmFolder inbox = olm.GetFolder("Inbox", true);

    // get a sub-folder of Inbox by name
    OlmFolder archive = inbox.GetSubFolder("Archive", true);

    if (archive != null)
    {
        Console.WriteLine($"Found sub-folder: {archive.Name}");
    }
}

Získat cesty složek

Úplnou cestu ke složce můžete získat pomocí OlmFolder.Path vlastnost. Následující úryvek vytiskne cestu každé složky v souboru:

using (var storage = new OlmStorage("SampleOLM.olm"))
{
    PrintPath(storage.FolderHierarchy);
}

public static void PrintPath(IEnumerable<OlmFolder> folders)
{
    foreach (OlmFolder folder in folders)
    {
        // print the current folder path
        Console.WriteLine(folder.Path);

        PrintPath(folder.SubFolders);
    }
}

Net: Čtení a extrakce OLM zpráv

Mon, 01 Jan 0001 00:00:00 +0000

Po otevření souboru OLM a nalezení složky můžete vypsat její zprávy, přečíst stručné informace o zprávě, filtrovat a stránkovat velké složky a extrahovat jednotlivé zprávy jako MapiMessage objekty. Tento článek pokrývá všechny tyto operace.

Vypsat zprávy ve složce

The OlmFolder třída poskytuje dva způsoby, jak iterovat přes zprávy, které obsahuje:

EnumerateMessages vrací OlmMessageInfo objekt v každé iteraci. Tento objekt obsahuje stručné informace o zprávě a je nejefektivnějším způsobem, jak procházet složku.
EnumerateMapiMessages vrací kompletní MapiMessage objekt v každé iteraci, se všemi načtenými vlastnostmi zprávy.

Použití EnumerateMessages

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);
    foreach (var messageInfo in folder.EnumerateMessages())
    {
        Console.WriteLine(messageInfo.Subject);
    }
}

Použití EnumerateMapiMessages

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    foreach (var msg in folder.EnumerateMapiMessages())
    {
        // save the message in MSG format
        msg.Save($"{msg.Subject}.msg");
    }
}

Číst informace o zprávě

Každý OlmMessageInfo objekt vystavuje sadu pouze pro čtení vlastností popisujících zprávu bez načítání jejího úplného obsahu. Toto je nejefektivnější způsob, jak vytvořit seznamový pohled nebo rozhodnout, které zprávy extrahovat.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    foreach (OlmMessageInfo messageInfo in folder.EnumerateMessages())
    {
        Console.WriteLine($"Subject: {messageInfo.Subject}");
        Console.WriteLine($"From: {messageInfo.From}");
        Console.WriteLine($"To: {string.Join("; ", messageInfo.To)}");
        Console.WriteLine($"Date: {messageInfo.Date}");
        Console.WriteLine($"Modified: {messageInfo.ModifiedDate}");
        Console.WriteLine($"Has attachments: {messageInfo.HasAttachments}");
        Console.WriteLine($"Message class: {messageInfo.MessageClass}");
        Console.WriteLine(new string('-', 30));
    }
}

Získat upravené datum zprávy

Upravené datum představuje datum a čas, kdy byla OLM zpráva naposledy upravena. Použijte OlmMessageInfo.ModifiedDate vlastnost pro jeho přečtení:

foreach (OlmMessageInfo messageInfo in inboxFolder.EnumerateMessages())
{
    DateTime modifiedDate = messageInfo.ModifiedDate;
}

Filtrujte zprávy pomocí dotazu

Pro velké složky můžete získat pouze zprávy, které splňují určitá kritéria, místo iterace přes vše. Předávejte MailQuery na EnumerateMessages(MailQuery query) přetížení. Sestavte dotaz pomocí MailQueryBuilder.

Níže uvedený příklad enumeruje pouze zprávy přijaté během posledních sedmi dnů, jejichž předmět obsahuje slovo „Invoice“:

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    var builder = new MailQueryBuilder();
    builder.InternalDate.Since(DateTime.Now.AddDays(-7));
    builder.Subject.Contains("Invoice");
    MailQuery query = builder.GetQuery();

    foreach (var messageInfo in folder.EnumerateMessages(query))
    {
        Console.WriteLine(messageInfo.Subject);
    }
}

Stránkovat zprávy

Když složka obsahuje velké množství zpráv, můžete je číst po dávkách pomocí EnumerateMessages(int skip, int count) přetížení. Metoda skip parametr je počet zpráv, které mají být přeskočeny, a count je počet zpráv, které mají být vráceny.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    const int pageSize = 50;
    int pageIndex = 0;

    while (true)
    {
        var page = folder.EnumerateMessages(pageIndex * pageSize, pageSize).ToList();
        if (page.Count == 0)
        {
            break;
        }

        foreach (var messageInfo in page)
        {
            Console.WriteLine(messageInfo.Subject);
        }

        pageIndex++;
    }
}

Extrahovat zprávu jako MapiMessage

The OlmStorage třída poskytuje ExtractMapiMessage metoda, která extrahuje kompletní MapiMessage z OlmMessageInfo objekt. To je užitečné, když nejprve skenujete složku pomocí EnumerateMessages a poté extrahovat pouze zprávy, které skutečně potřebujete.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    foreach (var messageInfo in folder.EnumerateMessages())
    {
        if (messageInfo.Date.Date == DateTime.Today)
        {
            // extract today's messages from Inbox
            var msg = olm.ExtractMapiMessage(messageInfo);
            msg.Save($"{msg.Subject}.msg");
        }
    }
}

Extrahovat zprávy podle identifikátoru

Někdy potřebujete extrahovat vybrané zprávy podle jejich identifikátorů. Například aplikace může ukládat identifikátory v databázi a extrahovat zprávu na požádání místo opakovaného procházení celého úložiště. Tento EntryId vlastnost třídy OlmMessageInfo poskytuje identifikátor vstupu zprávy a přetížená ExtractMapiMessage(string id) metoda získá zprávu podle tohoto identifikátoru.

using (var olm = OlmStorage.FromFile(fileName))
{
    var olmFolder = olm.GetFolder("Inbox", true);

    foreach (OlmMessageInfo msgInfo in olmFolder.EnumerateMessages())
    {
        // store msgInfo.EntryId somewhere, then later:
        MapiMessage msg = olm.ExtractMapiMessage(msgInfo.EntryId);
    }
}

Extrahovat položky pomocí Traversal API

Můžete extrahovat každou položku z OLM souboru – pokud je to možné – bez vyhazování výjimek, i když jsou některá data v původním souboru poškozena. K tomu vytvořte OlmStorage instance s OlmStorage(TraversalExceptionsCallback callback) konstruktor a načtěte soubor pomocí Load metoda. Callback vystavuje výjimky při načítání a procházení.

The Load metoda vrací true pokud byl soubor načten úspěšně a procházení je možné, a false pokud je soubor poškozený a není možné jej projít. Všimněte si, že při procházení položek složka po složce voláte úložiště EnumerateMessages(OlmFolder folder) metoda, předávající složku jako argument.

Kroky jsou:

Vytvořit nový OlmStorage instance, předáním callbacku pro zpracování výjimek.
Načtěte soubor OLM voláním Load metoda.
Pokud se soubor načte úspěšně, získejte hierarchii složek voláním GetFolders.
Rekurzivně iterovat přes každou složku. Pro složky, které obsahují zprávy, je enumerovat pomocí úložiště EnumerateMessages metoda a zpracovat každou z nich.
Rekurzivně vstoupit do všech pod‑složek.

using (var olm = new OlmStorage((exception, id) => { /* Exception handling code. */ }))
{
    if (olm.Load(fileName))
    {
        var folderHierarchy = olm.GetFolders();
        ExtractItems(olm, folderHierarchy);
    }
}

private static void ExtractItems(OlmStorage olm, IEnumerable<OlmFolder> folders)
{
    foreach (var folder in folders)
    {
        if (folder.HasMessages)
        {
            Console.WriteLine(folder);

            foreach (var msg in olm.EnumerateMessages(folder))
            {
                Console.WriteLine(msg.Subject);
            }
        }

        ExtractItems(olm, folder.SubFolders);
    }
}

Net: Počítání položek a práce s kategoriemi

Mon, 01 Jan 0001 00:00:00 +0000

Kromě čtení jednotlivých zpráv vám Aspose.Email pro .NET umožňuje zjistit, kolik položek soubor OLM nebo složka obsahuje, a číst Outlook kategorie – včetně jejich barev – které jsou v souboru uloženy. Tento článek pokrývá obojí.

Zkontrolovat, zda složka obsahuje zprávy

The OlmFolder.HasMessages vlastnost udává, zda složka obsahuje nějaké zprávy, a OlmFolder.MessageCount vlastnost vrací kolik.

using (var olm = OlmStorage.FromFile(fileName))
{
    var folder = olm.GetFolder("Inbox", true);

    if (folder.HasMessages)
    {
        Console.WriteLine($"Message count: {folder.MessageCount}");
    }
}

Počítat položky v každé složce

Použijte OlmFolder.MessageCount vlastnost pro hlášení počtu položek v každé složce souboru:

using (var storage = new OlmStorage("SampleOLM.olm"))
{
    PrintMessageCount(storage.FolderHierarchy);
}

public static void PrintMessageCount(IEnumerable<OlmFolder> folders)
{
    foreach (OlmFolder folder in folders)
    {
        Console.WriteLine($"Message Count [{folder.Name}]: {folder.MessageCount}");

        PrintMessageCount(folder.SubFolders);
    }
}

Získat celkový počet položek v úložišti

The OlmStorage třída má GetTotalItemsCount() metodu, která vrací celkový počet položek zpráv obsažených v celém úložišti OLM:

using (var olm = new OlmStorage("storage.olm"))
{
    var count = olm.GetTotalItemsCount();
    Console.WriteLine($"Total items: {count}");
}

Získání barev kategorií Outlooku

Pro práci s kategoriemi položek Outlook uloženými v souboru OLM Aspose.Email nabízí:

tento OlmItemCategory třída – představuje kategorii položky Outlook, dostupnou podle její Name a související Barva, vyjádřeno v hexadecimálním formátu;
tento GetCategories() metoda třídy OlmStorage třída – získává seznam kategorií použité v úložišti.

Následující ukázka vypisuje všechny kategorie použité v úložišti spolu s jejich barvou:

using (var olm = OlmStorage.FromFile("storage.olm"))
{
    var categories = olm.GetCategories();

    foreach (var category in categories)
    {
        Console.WriteLine($"Category name: {category.Name}");

        // Color is represented as a hexadecimal value: #rrggbb
        Console.WriteLine($"Category color: {category.Color}");
    }
}

Získat barvu kategorie zprávy

Můžete porovnat kategorie přiřazené konkrétní zprávě se seznamem kategorií úložiště, abyste zjistili barvu každé kategorie. Níže uvedený příklad čte kategorie každé zprávy ve složce a vypisuje barvu každé z nich:

using (var olm = OlmStorage.FromFile("storage.olm"))
{
    var categories = olm.GetCategories();
    var folder = olm.GetFolder("Inbox", true);

    foreach (var msg in folder.EnumerateMapiMessages())
    {
        if (msg.Categories != null)
        {
            foreach (var msgCategory in msg.Categories)
            {
                Console.WriteLine($"Category name: {msgCategory}");

                var category = categories
                    .FirstOrDefault(c => c.Name.Equals(msgCategory, StringComparison.OrdinalIgnoreCase));

                Console.WriteLine(category != null
                    ? $"Category color: {category.Color}"
                    : "Category color: Not found");
            }
        }
    }
}

Net: Převod OLM na PST

Mon, 01 Jan 0001 00:00:00 +0000

OLM je databázový formát souboru používaný Microsoft Outlook pro Mac. OLM soubory ukládají e‑mailové zprávy, kalendářová data, kontakty a nastavení aplikace a nejsou podporovány Outlookem pro Windows. Pro migraci poštovní schránky z Outlooku pro Mac do Outlooku pro Windows musíte převést OLM soubor do formátu Outlook PST formát. Aspose.Email pro .NET vám umožní to provést v kódu, bez nutnosti mít nainstalovaný Microsoft Outlook.

Jak funguje převod

Pro převod OLM souboru do PST postupujte podle těchto kroků:

Vytvořte instanci OlmStorage class pro otevření zdrojového souboru OLM.
Vytvořte nový PST soubor pomocí PersonalStorage.Create metoda.
Implementujte GetContainerClass metodu, která mapuje třídu zprávy na odpovídající třídu složky (kontejneru), takže každá složka je v PST vytvořena se správným typem.
Implementujte AddToPst metody, která rekurzivně čte každou složku a její zprávy z OLM souboru – pomocí EnumerateMapiMessages - a přidá je do PST ve stejném pořadí pomocí AddSubFolder a AddMessage metody z FolderInfo.

Ukázkový kód

Následující kód ukazuje, jak převést OLM soubor na PST.

Metoda Main:

// create an instance of OlmStorage class to open the source OLM
using (var olm = new OlmStorage("my.olm"))
// create a new PST file
using (var pst = PersonalStorage.Create("my.pst", FileFormatVersion.Unicode))
{
    // recursively read each folder and its messages
    // and add them to the PST in the same order
    foreach (var olmFolder in olm.FolderHierarchy)
    {
        AddToPst(pst.RootFolder, olmFolder);
    }
}

Metoda GetContainerClass:

public string GetContainerClass(string messageClass)
{
    if (messageClass.StartsWith("IPM.Contact") || messageClass.StartsWith("IPM.DistList"))
    {
        return "IPF.Contact";
    }

    if (messageClass.StartsWith("IPM.StickyNote"))
    {
        return "IPF.StickyNote";
    }

    if (messageClass.StartsWith("IPM.Activity"))
    {
        return "IPF.Journal";
    }

    if (messageClass.StartsWith("IPM.Task"))
    {
        return "IPF.Task";
    }

    if (messageClass.StartsWith("IPM.Appointment") || messageClass.StartsWith("IPM.Schedule.meeting"))
    {
        return "IPF.Appointment";
    }

    return "IPF.Note";
}

Metoda AddToPst:

public void AddToPst(FolderInfo pstFolder, OlmFolder olmFolder)
{
    FolderInfo pstSubFolder = pstFolder.GetSubFolder(olmFolder.Name);

    foreach (var msg in olmFolder.EnumerateMapiMessages())
    {
        if (pstSubFolder == null)
        {
            pstSubFolder = pstFolder.AddSubFolder(olmFolder.Name, GetContainerClass(msg.MessageClass));
        }

        pstSubFolder.AddMessage(msg);
    }

    if (pstSubFolder == null)
    {
        pstSubFolder = pstFolder.AddSubFolder(olmFolder.Name);
    }

    foreach (var olmSubFolder in olmFolder.SubFolders)
    {
        AddToPst(pstSubFolder, olmSubFolder);
    }
}

Převod v opačném směru (z PST do OLM) není podporován, protože OLM soubor je vždy vytvořen Outlookem pro Mac při přidání účtu a synchronizaci s poštovním serverem.