Convert Microsoft Project MPP File

This article describes how to convert Microsoft Project MPP files to various output formats including HTML, plain text, and Microsoft Project Template (MPT) using Aspose.Tasks for .NET. The API provides a comprehensive set of features for customizing the output, including resource handling, header settings, styling options, and content filtering. Each format is covered with practical examples and optional customization steps.

Microsoft Project (MSP) allows developers to save project data (MPP/XML) to HTML, text and MPT templates. Aspose.Tasks also allows you to save project data to the same formats similar to MSP. This is achieved using the standard Save method exposed by the Project class.

Save Project Data as HTML

The HtmlSaveOptions class allows developers to control the layout and content of exported HTML files. It supports multi-page export, page size configuration, timescale selection, and embedding or externalizing CSS, fonts, and images. Aspose.Tasks can export project data to HTML format. It allows to save all the data to HTML or export only required pages to HTML by using the SaveOptions as shown in the following code samples.

Project project = new Project("New Project.mpp");
HtmlSaveOptions option = new HtmlSaveOptions();
project.Save("SaveProjectDataAsHTML_out.html", option);

// OR

// Adding only one page (page number 2)
option = new HtmlSaveOptions();
option.Pages.Add(2); 
project.Save("SaveProjectDataAsHTML2_out.html", option);

Controlling Header and Title Output in HTML

By default, the exported HTML document includes the project name in the HTML <title> and in the document’s page header. You can disable either of these elements by modifying the corresponding properties of the HtmlSaveOptions class.

Project project = new Project("New Project.mpp");
HtmlSaveOptions htmlSaveOptions = new HtmlSaveOptions();

// Determines whether to include project name in HTML title (true by default)
htmlSaveOptions.IncludeProjectNameInTitle = false;

// Determines whether to include project name in HTML page header  (true by default)
htmlSaveOptions.IncludeProjectNameInPageHeader = false;
htmlSaveOptions.Pages = new List<int>();
htmlSaveOptions.Pages.Add(1);
project.Save("ControlHeaderNameDuringHTMLExport_out.html", htmlSaveOptions);

Saving Fonts, Images and CSS Styles Separately

Aspose.Tasks supports saving fonts, images, and CSS styles as external files. This is particularly useful when you want to integrate HTML output into an existing website or manage styling separately from the content. This is achieved using the HtmlSaveOptions class by providing information about CSS, Font and Image destinations. The resource export behavior can be configured through HtmlSaveOptions.ExportFonts, ExportImages, and ExportCss.

public class ResourcePrefixForNestedResources : ICssSavingCallback, IFontSavingCallback, IImageSavingCallback
{
    public static void Run()
    {
        Project project = new Project("New Project.mpp");
        HtmlSaveOptions options = GetSaveOptions(1);
        project.Save("document.html", options);
    }

    public void CssSaving(CssSavingArgs args)
    {
        FileStream stream = new FileStream("css/" + args.FileName, FileMode.Create);
        args.Stream = stream;
        args.KeepStreamOpen = false;
        args.Uri = "css/" + args.FileName;
    }

    public void FontSaving(FontSavingArgs args)
    {
        FileStream stream = new FileStream("fonts/" + args.FileName, FileMode.Create);
        args.Stream = stream;
        args.KeepStreamOpen = false;
        args.Uri = "fonts/" + args.FileName;
    }

    public void ImageSaving(ImageSavingArgs args)
    {
        if (args.FileName.EndsWith("png"))
        {
            FileStream stream1 = new FileStream("resources/nestedResources/" + args.FileName, FileMode.Create);
            args.Stream = stream1;
            args.KeepStreamOpen = false;
            args.Uri = "resources/" + args.FileName;
            args.NestedUri = "nestedResources/" + args.FileName;
        }
        else
        {
            FileStream stream2 = new FileStream("resources/" + args.FileName, FileMode.Create);
            args.Stream = stream2;
            args.KeepStreamOpen = false;
            args.Uri = "resources/" + args.FileName;
        }
    }

    private static HtmlSaveOptions GetSaveOptions(int pageNumber)
    {
        HtmlSaveOptions options = new HtmlSaveOptions
        {
            Pages = new List<int>(),
            IncludeProjectNameInPageHeader = false,
            IncludeProjectNameInTitle = false,
            PageSize = PageSize.A3,
            Timescale = Timescale.ThirdsOfMonths,
            ReduceFooterGap = true,
            FontFaceTypes = FontFaceType.Ttf,
            ExportCss = ResourceExportType.AsFile,
            ExportFonts = ResourceExportType.AsFile,
            ExportImages = ResourceExportType.AsFile
        };

        ResourcePrefixForNestedResources program = new ResourcePrefixForNestedResources();
        options.FontSavingCallback = program;
        options.CssSavingCallback = program;
        options.ImageSavingCallback = program;

        options.Pages.Clear();
        options.Pages.Add(pageNumber);

        if (!Directory.Exists("fonts"))
        {
            Directory.CreateDirectory("fonts");
        }

        if (!Directory.Exists("resources"))
        {
            Directory.CreateDirectory("resources");
        }

        if (!Directory.Exists("nestedResources"))
        {
            Directory.CreateDirectory("resources/nestedResources");
        }

        if (!Directory.Exists("css"))
        {
            Directory.CreateDirectory("css");
        }

        return options;
    }
}

Adding Custom Prefixes to CSS Class Names While Exporting to HTML

To avoid CSS class name conflicts when integrating the exported HTML into a broader application, you can define a custom prefix using the CssStylePrefix property.

Project project = new Project("New Project.mpp");

HtmlSaveOptions options = new HtmlSaveOptions
{
    CssStylePrefix = "test_prefix"
};

project.Save("TestCssStylePrefix_out.html", options);

Save Project to Text

Project data can be exported to plain text using SaveFileFormat.TXT. This format is intended for simple logging, debugging, or archival purposes.

Project project = new Project("New Project.mpp");
project.Save("SaveProjectAsText_out.txt", SaveFileFormat.TXT);

Save Project Data as Template (MPT)

Aspose.Tasks allows saving a project as a Microsoft Project Template (MPT) file. This is useful when you want to create reusable project structures. Use the SaveAsTemplate method and configure optional parameters through the SaveTemplateOptions class to remove actual and baseline values.

Project project = new Project("New Project.mpp");
ProjectFileInfo projectFileInfo = Project.GetProjectFileInfo("New Project.mpp");

if (FileFormat.MPP14 == projectFileInfo.ProjectFileFormat)
{
    Console.WriteLine("Project file format is ok");
}

SaveTemplateOptions options = new SaveTemplateOptions();
options.RemoveActualValues = true;
options.RemoveBaselineValues = true;

project.SaveAsTemplate("SaveProjectDataAsTemplate_out.mpt");

ProjectFileInfo templateFileInfo = Project.GetProjectFileInfo(templateName);
if (FileFormat.MPT14 == templateFileInfo.ProjectFileFormat)
{
    Console.WriteLine("Template FileFormat is ok");
}

Conclusion

Aspose.Tasks for .NET provides flexible and developer-friendly methods for exporting project data to multiple formats, including HTML, text, and templates. With the help of configuration classes such as HtmlSaveOptions and SaveTemplateOptions, developers can fine-tune the output to meet a wide range of business requirements. For additional details, refer to the API Reference or explore other export scenarios in the documentation.