ABP and maildev

Tue, 15 Jul 2025 17:32:04 Z

In this article, we’ll show you how to easily view emails sent by your ABP application with minimal effort. This can be helpful during the development phase for obvious reasons. We’ll use maildev for this. However, what we’re demonstrating should work with similar tools as well.
Go to the Post

PoC of using GrapesJS for ABPs CMS Kit

Wed, 11 Sep 2024 13:50:50 Z

A proof of concept on how to get started using GrapesJS as an editor for CMS Kit.
Go to the Post

ABP Modules and Entity Dependencies

Sat, 12 Aug 2023 12:25:42 Z

This post briefly discusses abp module definition and provides an example of how to handle entity synchronization between modules.
Go to the Post

Using Switch Startup Project Extension for Visual Studio

Sun, 17 Apr 2022 12:20:51 Z

Using Switch Startup Project Extension

In this article, I want to show how I use the Switch Startup Project Extension to make development of an ABP Framework application a little bit faster.

I am not the developer of the extension.

Problem and assumptions made

When developing an ABP Framework application, you'll often have to start and debug multiple projects at once.

Let's assume you haven't set up containerization/ orchestration and you have a setup where your stack is somehow tiered (like blazor wasm, where you have to start the WebAssembly Project and the HttpApi.Host at once).

Normally you would do something like this:

And every time you need to execute something different, you change your startup projects accordingly.

How the extension tackles this

With the extenmsion installed, you can simplify this process.

Configure the extension for your project by clicking this button:

A new window will open with a json file, where you can set everything as you need.

/*
    This is a configuration file for the SwitchStartupProject Visual Studio Extension
    See https://heptapod.host/thirteen/switchstartupproject/blob/branch/current/Configuration.md
*/
{
  /*  Configuration File Version  */
  "Version": 3,
    
  /*  Create an item in the dropdown list for each project in the solution?  */
  "ListAllProjects": false,

  "MultiProjectConfigurations": {
    "Web App": {
      "Projects": {
        "RackManager.HttpApi.Host": {},
        "RackManager.Blazor": {}
      }
    },
    "ERP Connector Console": {
      "Projects": {
        "RackManager.HttpApi.Host": {},
        "RackManager.ERPConnector.ConsoleApp": {}
      }
    },
    "Android (mobile app only)": {
      "Projects": {
        "RackManager.MobileApp.Android": {}
      }
    },
    "Android": {
      "Projects": {
        "RackManager.HttpApi.Host": {},
        "RackManager.MobileApp.Android": {}
      }
    },
    "DbMigrator": {
      "Projects": {
        "RackManager.DbMigrator": {}
      }
    }
  }
}

The process is self explaining. You'll end up with a configuration file which is valid for your current solution. You can add it to your source control to allow every consumer to have the same experience (as long as they have this extension installed).

And that's it. You can now pick what you need from the dropdown without ever having to think about setting things up again.

Generate PDF's in an ABP Framework Project using Scryber.Core

Sun, 17 Apr 2022 11:04:03 Z

Generate PDF's in an ABP Framework Project using Scryber.Core

In this article, we'll create a basic application with blazor-server for UI to demonstrate how generating PDF's can be implemented in an ABP project. To archieve this, we will use Scryber.Core.

For the sake of simplicity I will reduce everything to the bare minimum just so that you get a picture of how everything works together. PDF's will be generated server side. This post will show how to download the generated PDF file. If you are using a different UI layer, you just need to implement your download a bit different.

The source code for this can be found here.

Creating the Solution

For this article, we will create a simple application with blazor-server for our UI. Feel free to use something different. I'll showcase a download of the pdf file

We can create a new startup template with EF Core as a database provider and MVC for the UI Framework.

If you already have a project, you don't need to create a new startup template, you can directly implement the following steps to your project. So you can skip this section. We can create a new startup template by using the ABP CLI.

abp new BookStorePdf -t app -u blazor-server -d ef

After running the above command, our project boilerplate will be downloaded. Then we can open the solution and start the development.

Starting the Development

First of all we add the initial migration. There are multiple ways doing that. I like to do it like this:

Set BookStorePdf.EntityFrameworkCore as startup project
Open Package Manager Console and ensure Default Project is the same
Execute Add-Migration "Initial"
Execute BookStorePdf.DbMigrator

We can now start up BookStorePdf.Blazor and ensure that everything works correctly.

Add Scryber.core

We are now ready to install Scryber.Core.

Add the Scryber.Core NuGet-Package to BookStorePdf.Application.

BookStorePdf.Application.csproj now looks like this:



  

  
    net6.0
    BookStorePdf

Managing PDF templates

To generate PDF's with scryber, we need to have templates. For this tutorial we will use html files which we ship along with the application. You can however write a complete ecosystem around this to be able to have the templates changeable by your users.

Let's implement everything we need to store and serve our html file.

Create IResourceAppService.cs in the BookStorePdf.Application.Contracts project with the following content:

using Microsoft.Extensions.FileProviders;
using Volo.Abp.Application.Services;
using Volo.Abp.DependencyInjection;

namespace BookStorePdf;

public interface IResourceAppService : IApplicationService, ITransientDependency
{
    IFileInfo GetFileInfo(string path);
}

After that you create ResourceAppService in the BookStorePdf.Application project with this content:

using Microsoft.Extensions.FileProviders;
using Volo.Abp.VirtualFileSystem;

namespace BookStorePdf;

public class ResourceAppService : BookStorePdfAppService, IResourceAppService
{
    private readonly IVirtualFileProvider _virtualFileProvider;

    public ResourceAppService(IVirtualFileProvider virtualFileProvider)
    {
        _virtualFileProvider = virtualFileProvider;
    }

    public IFileInfo GetFileInfo(string path)
    {
        return _virtualFileProvider.GetFileInfo(path);
    }
}

Change BookStorePdfApplicationModule.cs like this:

using Volo.Abp.Account;
using Volo.Abp.AutoMapper;
using Volo.Abp.FeatureManagement;
using Volo.Abp.Identity;
using Volo.Abp.Modularity;
using Volo.Abp.PermissionManagement;
using Volo.Abp.SettingManagement;
using Volo.Abp.TenantManagement;
using Volo.Abp.VirtualFileSystem;

namespace BookStorePdf;

[DependsOn(
    typeof(BookStorePdfDomainModule),
    typeof(AbpAccountApplicationModule),
    typeof(BookStorePdfApplicationContractsModule),
    typeof(AbpIdentityApplicationModule),
    typeof(AbpPermissionManagementApplicationModule),
    typeof(AbpTenantManagementApplicationModule),
    typeof(AbpFeatureManagementApplicationModule),
    typeof(AbpSettingManagementApplicationModule)
    )]
public class BookStorePdfApplicationModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        Configure(options =>
        {
            options.AddMaps();
        });

        // add this here
        Configure(options =>
        {
            options.FileSets.AddEmbedded();
        });
    }
}

Change BookStorePdf.Application.csproj:



  

  
      net6.0
      BookStorePdf
      
	  
	  true
  

  
    
    
  

  
	  
	  
      
	  
      
      
      
      
      
      
  

	
  
  	
  

	
	
		
			
				
					Always

This is needed to setup our file provider. We store our templates in the MyResources directory. If we debug, we want the templates to be copied to the output directory so that we can change them on runtime and see changes.

The debugging-part is possible because we have the following code in BookStorePdfBlazorModule.cs:

private void ConfigureVirtualFileSystem(IWebHostEnvironment hostingEnvironment)
    {
        if (hostingEnvironment.IsDevelopment())
        {
            Configure(options =>
            {
                options.FileSets.ReplaceEmbeddedByPhysical(Path.Combine(hostingEnvironment.ContentRootPath, $"..{Path.DirectorySeparatorChar}BookStorePdf.Domain.Shared"));
                options.FileSets.ReplaceEmbeddedByPhysical(Path.Combine(hostingEnvironment.ContentRootPath, $"..{Path.DirectorySeparatorChar}BookStorePdf.Domain"));
                options.FileSets.ReplaceEmbeddedByPhysical(Path.Combine(hostingEnvironment.ContentRootPath, $"..{Path.DirectorySeparatorChar}BookStorePdf.Application.Contracts"));
                options.FileSets.ReplaceEmbeddedByPhysical(Path.Combine(hostingEnvironment.ContentRootPath, $"..{Path.DirectorySeparatorChar}BookStorePdf.Application"));
                options.FileSets.ReplaceEmbeddedByPhysical(hostingEnvironment.ContentRootPath);
            });
        }
    }

When we deploy the application, we want to have everything stored as an embedded resource.

Now we create a folder MyResources and create a template file called Test.html there for our PDF's.




    Hello World


    Hello World from scryber.

Create the printing service

Now we start to implement a service which we can consume to generate a pdf. We will start with something simple.

Create IPrintingAppService.cs in the BookStorePdf.Application.Contracts project with the following content:

using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.DependencyInjection;

namespace BookStorePdf;

public interface IPrintingAppService : IApplicationService, ITransientDependency
{
    Task PrintAsync();
}

After that you create PrintingAppService in the BookStorePdf.Application project with this content:

using Scryber.Components;
using System;
using System.IO;
using System.Threading.Tasks;

namespace BookStorePdf;

public class PrintingAppService : BookStorePdfAppService, IPrintingAppService
{
    private readonly IResourceAppService _resourceAppService;

    public PrintingAppService(IResourceAppService resourceAppService)
    {
        _resourceAppService = resourceAppService;
    }

    public async Task PrintAsync()
    {
        // get desired template from resource service into a stream
        var info = _resourceAppService.GetFileInfo("/MyResources/Test.html");
        using var stream = info.CreateReadStream();

        // use scryber to parse the stream into a document
        using var doc = Document.ParseDocument(stream, Scryber.ParseSourceType.Resource);
        
        // create some file to write the pdf to.
        // in a real world scenario you would remove the file after you're done
        var tmpDir = System.IO.Path.GetTempPath();
        var name = Guid.NewGuid().ToString() + ".pdf";
        var targetFilename = System.IO.Path.Combine(tmpDir, name);

        // let scryber write the pdf file
        doc.SaveAsPDF(targetFilename, FileMode.OpenOrCreate);
        
        // read created pdf file into bytes and return to consumer
        return await File.ReadAllBytesAsync(targetFilename);
    }
}

Download PDF

The last step is getting our UI ready to consume the IPrintingAppService and download our pdf.

Add this to your Blazor project:

export async function downloadFileFromStream(fileName, contentStreamReference) {
    const arrayBuffer = await contentStreamReference.arrayBuffer();
    const blob = new Blob([arrayBuffer]);
    const url = URL.createObjectURL(blob);

    triggerFileDownload(fileName, url);

    URL.revokeObjectURL(url);
}

function triggerFileDownload(fileName, url) {
    const anchorElement = document.createElement('a');
    anchorElement.href = url;
    anchorElement.download = fileName ?? '';
    anchorElement.click();
    anchorElement.remove();
}

Change Index.razor to this:

@page "/"

@inherits BookStorePdfComponentBase

Change Index.razor.cs to this:

using Microsoft.JSInterop;
using System.IO;
using System.Threading.Tasks;

namespace BookStorePdf.Blazor.Pages;

public partial class Index
{
    private readonly IJSRuntime _jsRuntime;
    private readonly IPrintingAppService _printingAppService;
    private IJSObjectReference _jsModule;

    public Index(IJSRuntime jsRuntime, IPrintingAppService printingAppService)
    {
        _jsRuntime = jsRuntime;
        _printingAppService = printingAppService;
    }

    protected override async Task OnInitializedAsync()
    {
        _jsModule = await _jsRuntime.InvokeAsync("import", "./scripts/myscripts.js");
    }

    private async Task PrintTestAsync()
    {
        var result = await _printingAppService.PrintAsync();

        var fileName = "Test.pdf";

        using var fileStream = new MemoryStream(result);
        using var streamRef = new DotNetStreamReference(stream: fileStream);

        await _jsModule.InvokeVoidAsync("downloadFileFromStream", fileName, streamRef);
    }
}

ABP.IO Stories

ABP and maildev

PoC of using GrapesJS for ABPs CMS Kit

ABP Modules and Entity Dependencies

Using Switch Startup Project Extension for Visual Studio

Using Switch Startup Project Extension

Problem and assumptions made

How the extension tackles this

Generate PDF's in an ABP Framework Project using Scryber.Core

Generate PDF's in an ABP Framework Project using Scryber.Core

Creating the Solution

Starting the Development

Add Scryber.core

Managing PDF templates

Create the printing service

Download PDF

Result

Further Reading