In this article, I will talk about the relationships of IdentityUser in every web application that can be created with the ABP framework. When you read this article, you will learn how to extend the user entity in the applications you develop using the ABP framework with a primitive type, extending the user by associating the user with another entity (User-many-to-one-X).

Creating the Solution

For the source code of the application: https://github.com/onurpicakci/Abp-Identity-Relationship

In this article we will use EF Core as the database provider and MVC as the user interface framework. But Angular, Blazor Server and Blazor WebAssembly also work. ABP Framework offers starter templates to get started faster. We can create a new starter template using the ABP CLI:

abp new IdentityRelationship

After the project is created, you can run the IdentityRelationship.DbMigrator project to create the database and seed the initial data. You can then run the IdentityRelationship.Web project to see our application run.

The default admin username is admin and the password is 1q2w3E*

Module Entity Extensions

The module entity extension system is a high level extension system that allows you to define new properties for existing entities of the depended modules. It automatically adds properties to the entity, database, HTTP API and the user interface in a single point.

Extending the User Entity With a Primitive Type

Open the IdentityRelationshipModuleExtensionConfigurator class inside the Domain.Shared project of your solution and change the ConfigureExtraProperties method as shown below to add an IdentificationNumber property to the IdentityUser entity of the Identity Module.

public static void ConfigureExtraProperties()
{
    OneTimeRunner.Run(() =>
    {
        ObjectExtensionManager.Instance.Modules()
            .ConfigureIdentity(identity =>
            {
                identity.ConfigureUser(user =>
                {
                    user.AddOrUpdateProperty<string>( //property type: string
                        "IdentificationNumber", //property name
                        property =>
                        {
                            //validation rules
                            property.Attributes.Add(string.Empty);
                            property.Attributes.Add(
                                new StringLengthAttribute(64) {
                                    MinimumLength = 4
                                }
                            );

                            //...other configurations for this property
                        }
                    );
                });
            });
    });
}

This method is called inside the IdentityRelationshipDomainSharedModule at the beginning of the application. OneTimeRunner is a utility class that guarantees to execute this code only one time per application, since multiple calls are unnecessary.

If you want to localize, open the IdentityRelationship.Domain.Shared project and create a new localization in your /Localization/IdentityRelationship/en.json file.

 "IdentificationNumber": "Identification Number"

Once you define a property, it appears in the create and update forms of the related entity:

New properties also appear in the data table of the related page:

Navigation Properties / Foreign Keys

It is supported to add an extension property to an entity that is the Id of another entity (foreign key).

Example: Let's associate a department in the database with a user

First, create a Departments folder in the IdentityRelationship.Domain project and add the Department class inside:

using System;
using Volo.Abp.Domain.Entities;

namespace IdentityRelationship.Departments;

public class Department : AggregateRoot<Guid>
{
    public string Name { get; set; }
}

EF Core requires that you relate the entities with your DbContext. The easiest way to do so is adding a DbSet property to the IdentityRelationshipDbContext class in the IdentityRelationship.EntityFrameworkCore project, as shown below:

    public DbSet<Department> Departments { get; set; }

Then in the IdentityRelationship.EntityFrameworkCore project of your solution, open the /EntityFrameworkCore/IdentityRelationshipEfCoreEntityExtensionMappings class and update your code:

public static class IdentityRelationshipEfCoreEntityExtensionMappings
{
    private static readonly OneTimeRunner OneTimeRunner = new OneTimeRunner();

    public static void Configure()
    {
        IdentityRelationshipGlobalFeatureConfigurator.Configure();
        IdentityRelationshipModuleExtensionConfigurator.Configure();

        OneTimeRunner.Run(() =>
        {
            ObjectExtensionManager.Instance
                .MapEfCoreProperty<IdentityUser, Guid>(
                    "DepartmentId",
                    (entityBuilder, propertyBuilder) => { propertyBuilder.HasMaxLength(128); }
                );
                
        });
    }
}

This class can be used to map these extra properties to table fields in the database. Please read this document to improve your understanding of what we are doing.

We need to create a new migration to see the changes in the database. Open your EntityFrameworkCore project in the terminal and run the following command (this depends on the IDE you are using).

dotnet ef migrations add Create_Department_Entity

Finally, run the IdentityRelationship.DbMigrator project to update the database.

When you look at your database, you can see that the Department table has been added and DepartmentId has been added to your AbpUsers table.

It's good to have some initial data in the database before running the application. This section introduces the Data Seeding system of the ABP framework. You can skip this section if you don't want to create the data seeding, but it is suggested to follow along and learn this useful ABP Framework feature.

Create a class deriving from the IDataSeedContributor in the IdentityRelationship.Domain project by copying the following code:

using System;
using System.Threading.Tasks;
using IdentityRelationship.Departments;
using Volo.Abp.Data;
using Volo.Abp.DependencyInjection;
using Volo.Abp.Domain.Repositories;

namespace IdentityRelationship;

public class IdentityRelationshipDataSeederContributor
    : IDataSeedContributor, ITransientDependency
{
    private readonly IRepository<Department, Guid> _departmentRepository;

    public IdentityRelationshipDataSeederContributor(IRepository<Department, Guid> departmentRepository)
    {
        _departmentRepository = departmentRepository;
    }

    public async Task SeedAsync(DataSeedContext context)
    {
        if (await _departmentRepository.GetCountAsync() <= 0)
        {
            await _departmentRepository.InsertAsync(
                new Department
                {
                    Name = "Human Resources"
                },
                autoSave: true
            );

            await _departmentRepository.InsertAsync(
                new Department
                {
                    Name = "Production"
                },
                autoSave: true
            );
        }
    }
}

• This code simply uses the IRepository<Department, Guid> (the default repository) to insert two books to the database in case there weren't any books in it.

Run the IdentityRelationship.DbMigrator application to update the database:

Again, open the IdentityRelationshipModuleExtensionConfigurator class in the Domain.Shared project and add the following code:

user.AddOrUpdateProperty<Guid>(
    "DepartmentId",
    property =>
    {
        property.UI.Lookup.Url = "/api/app/department";
        property.UI.Lookup.DisplayPropertyName = "name";
    }
);

The UI.Lookup.Url option takes a URL to get the list of departments to select on the edit/create forms. This endpoint can be a typical controller, an auto API controller or any type of endpoint that returns a proper JSON response.

To localize, open the IdentityRelationship.Domain.Shared project and add it to your /Localization/IdentityRelationship/en.json file:

"DepartmentId": "Department"

Create a Departments folder in the IdentityRelationship.Application.Contracts project of your solution and add the DepartmentDto class in it

using System;
using Volo.Abp.Application.Dtos;
namespace IdentityRelationship.Departments;

public class DepartmentDto : EntityDto<Guid>

{
    public string Name { get; set; }
}

Now let's create an IDepartmentAppService interface in the Departments folder

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

namespace IdentityRelationship.Departments;

public interface IDepartmentAppService : IApplicationService
{
    public Task<ListResultDto<DepartmentDto>> GetAsync();
}

Time to implement the IDepartmentAppService interface. Create a Departments folder in your IdentityRelationship.Application project and add the DepartmentAppService class inside.

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityRelationship.Departments;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Domain.Repositories;

namespace IdentityRelationship.Department;

public class DepartmentAppService : IdentityRelationshipAppService, IDepartmentAppService
{
    private readonly IRepository<Departments.Department, Guid> _departmentRepository;

    public DepartmentAppService(IRepository<Departments.Department, Guid> departmentRepository)
    {
        _departmentRepository = departmentRepository;
    }

    public async Task<ListResultDto<DepartmentDto>> GetAsync()
    {
        var departments = await _departmentRepository.GetListAsync();
        return new ListResultDto<DepartmentDto>(
            ObjectMapper.Map<List<Departments.Department>, List<DepartmentDto>>(departments));
    }
}

DepartmentAppService is using the ObjectMapper to convert the Department objects to DepartmentDto objects. So, we need to define this mapping in the AutoMapper configuration.

Open the IdentityRelationshipApplicationAutoMapperProfile class inside the IdentityRelationship.Application project and add the following line to the constructor:

using AutoMapper;
using IdentityRelationship.Departments;

namespace IdentityRelationship;

public class IdentityRelationshipApplicationAutoMapperProfile : Profile
{
    public IdentityRelationshipApplicationAutoMapperProfile()
    {
        CreateMap<Departments.Department, DepartmentDto>();
    }
}

Run your IdentityRelationship.Web project and add a department to one of your users.

And it shows the department name on the data table:

Conclusion

In this article I talked about the use of the IdentityUser relationship and how to extend it. Thank you for reading the article, I hope it was useful. See you soon!

References

• https://docs.abp.io/en/abp/latest/Module-Entity-Extensions
• https://learn.microsoft.com/en-us/ef/core/modeling/relationships
• https://community.abp.io/posts/how-to-add-custom-properties-to-the-user-entity-rixchoha

Introduction

In this article I will explain how you can contribute to the open source ABP Framework. You will not only learn about the ABP Framework, but also how to contribute to an open source project, what are the standard rules, some git operations, etc.

What is Open Source?

Open source software is code designed to be publicly available. Anyone can view, use, modify and distribute the project and code. The fact that the code is open source makes it a natural community and open for improvement. This enables ideas and thoughts to spread rapidly.

What is ABP Framework?

ABP Framework is a complete infrastructure for building modern web applications following the best practices and guidelines of software development. ABP Framework is completely free, open source and community driven. ABP is a modular framework and Application Modules provide pre-built application functionalities.

Before Contribution

Before making any changes and trying to push them to the target repository we need to create a new issue if there are no issues with the work. If there is an existing issue, you can proceed through this issue. This way, no other developer will work on the same issue and your PR will have a better chance to be accepted.

Previous ABP Community Talk on this topic can be found here.

GitHub Issues

You may want to fix a known bug or work on a planned enhancement. See the issue list on GitHub.

Feature Requests

If you have a feature idea for the framework or modules, create an issue on GitHub or attend an existing discussion. Then you can implement it if it's embraced by the community.

How to Contribute to an Open Source Software?

There are some steps to contribute to OSS projects. You can follow the steps below.

Step 1: Fork the Project

The first thing we need to do now is to fork the open source project. Forking will create a copy of the project in your own GitHub account. This will allow users to make changes to the code without affecting the original repository. Just press the fork key in the project.

After forking, it will create a new repo in your own GitHub profile.

Step 2: Clone the Project

In order to develop the project, you need to clone it to your local. After clicking on the code button, select your preferred cloning method and copy the link. You can run the copied link on your local machine with the git clone command, but we will use GitHub Desktop. Press Open with GitHub Desktop and the repo will be installed on your local machine.

or alternatively use the git clone https://github.com/username/abp.git command

Step 3: Create a New Branch

In this step, you need to create a new branch of your own before you start developing it. Open the repo on GitHub Desktop and create a new branch. When creating a new branch, be careful which branch you create it on.

or alternatively use the git checkout -b new-branch command

Step 4: Development

Choose a suitable IDE to develop on the new branch you created. In order not to complicate things, we will create a Developers.md file and process it. Let's enter a sample text in the Developers file.

As you can see, all changes made to the repo are reflected directly on GitHub Desktop.

Step 5: Commit

The commit operation is used to save the changes you have made. It is useful to commit after certain operations are done in the project. It is useful to write a short sentence describing what you've done for the changes made in each commit. Press the Commit to <branch-name> button to commit.

or alternatively use the git add . and git commit -m "Added the Developer List" command

Step 6: Publish the Changes

The changes you have made so far are only visible on your local machine. You need to publish these changes to submit them to your forked repository. Please press the publish branch button to publish.

or alternatively use the git push origin new-branch command

Step 7: Create a Pull Request

After the push, the pull request Create Pull Request button will appear on GitHub Desktop. Click it and create a pull request.

You can also make a pull request from the repo in your GitHub profile.

Before creating the pull request, make sure that the branch you created is making changes to the correct branch. After briefly describing your changes in the title and description, click the Create pull request button. This will send a pull request to the original repository. If the pull request is approved and merged by the community, your changes will also appear in the main repository.

That's it! You have contributed your development to an open source project.

Conclusion

In this article, I showed you how you could contribute to the ABP Framework, an open source and community driven project. Thank you for reading the article, I hope it was useful. See you soon!

References

• https://opensource.guide/how-to-contribute/
• https://docs.abp.io/en/abp/latest/Contribution/Index