Sempre que for necessário representar um objeto que represente uma entidade de banco de dados, a arquitetura representa esse item como Entidade.

Todas as entidades devem herdar de FluentEntity ou superiores. Para que a arquitetura consiga tratar os dados de forma homogênea, faz-se necessário herdar sempre que possível de FluentEntity.

Vaja a hierarquia:

User < FluentEntity < BaseEntity

A implementação fica como a seguir:

public class User : FluentEntity
{
    [Key]
    public long Code { get; set; }

    public string Email { get; set; }

    public string Name { get; set; }
}

Referência: Toda entidade que represente um objeto que será salvo no banco de dados deve ter um ou mais identificadores (no exemplo é o Code) para que o orquestrador de dados da arquitetura consiga individualizar os dados de representação da entidade, portanto, uma propriedade do tipo que represente um identificador é obrigatória. Sempre identifique á com o atributo [Key], como no exemplo.

Referência: No exemplo acima, caso tente gravar o mesmo e-mail mais de uma vez, a seguinte inconsistência será acionada EntityExistsFluentValidationException.

É possível também definir chave composta. Nesse caso, faz-se necessário informar a ordem das chaves. Veja um exemplo:

public class User : FluentEntity
{
    [Key, Column(Order = 0)]
    public int PersonId { get; set; }

    [Key, Column(Order = 1)]
    public int PersonType { get; set; }

    public string Email { get; set; }

    public string Name { get; set; }
}

O mapeamento para o banco de dados será feito de forma automática, portando, caso o nome da tabela ou coluna do banco de dados não seja igual ao nome da propriedade, faz-se necessário decorar a entidade com alguns atributos conforme exemplo abaixo:

using System;
using System.ComponentModel.DataAnnotations.Schema;
using Fluent.Architecture.Model;

[Table("users")]
public class User: FluentEntity
{
    [Key] 
    [Column("id")]
    public int PersonId { get; set;  }

    [Column("registration_date")]
    public virtual DateTime RegistrationDate { get; set; }
}

Note que estamos usando

Table: pra definir o nome da tabela ou view.

Key: pra definir que é a chave primária da tabela.

Column: pra definir o nome da coluna no banco de dados referente a essa propriedade

Caso deseja criar entidades que não tenham interação com banco de dados, existem algumas formas de se fazer.

1. Criando uma classe abstrata que herde de FluentEntity.

public abstract class Reports : FluentEntity
{
    public int DataCount { get; set; }
}

2. Criando uma classe concreta que herde diretamente de BaseEntity. Veja a hierarquia:

User < BaseEntity

public class Reports : BaseEntity
{
    public int DataCount { get; set; }
}

3. Fazendo uso do atributo NotMapped.

[NotMapped]
public class Reports : FluentEntity
{
    public int DataCount { get; set; }
}

Note que esse atributo não se propaga para quem herde de Reports, Somente é válido para essa classe em específico. Se deseja propagação, utilize o modelo de herança de BaseEntity.

O atributo FluentRequired permite indicar que uma propriedade deve ser de preenchimento obrigatório, mesmo que no banco de dados não seja. A validação dessa propriedade pela arquitetura, leva em conta valores padrão como sendo não preenchimento. Por exemplo: Uma propriedade do tipo int com valor 0, é consideráda como não preenchida. A inconsistência de validação para o caso de não preenchimento é do tipo UiFieldRequiredFluentValidationException

Veja o exemplo:

public class User : FluentEntity
{
    [Key]
    public int Code { get; set; }

    [FluentRequired]
    public string Email { get; set; }
    
    public string Name { get; set; }
}

O atributo FluentRandomKeyValueOnAddAttribute indica que a arquitetura deve gerar de forma automática, um valor randômico para ser usado como chave da entidade. Veja o exemplo:

public class User : FluentEntity
{
    [Key]
    [FluentRandomKeyValueOnAdd]
    public int Code { get; set; }

    public string Email { get; set; }
    
    public string Name { get; set; }
}

No exemplo acima, ao cadastrar uma entidade, a arquitetura cuidará de gerar de forma automática um valor para a propriedade Code. Esse valor será exclusivo, com base em valores já existentes no banco de dados. Esse atributo pode ser usado em propriedades dos tipos int, double e string.

O atributo FluentUniqueKeyAttribute permite indicar que uma propriedade não deve permitir repetir o mesmo valor. Veja o exemplo de uso:

public class User : FluentEntity
{
    [Key]
    public int Code { get; set; }

    [FluentUniqueKey]
    public string Email { get; set; }

    public string Name { get; set; }
}

Referência: No exemplo acima, caso tente gravar o mesmo e-mail mais de uma vez, a seguinte inconsistência será acionada EntityExistsFluentValidationException.

O atributo SearchableAttribute permite indicar que uma propriedade será alvo de consulta por termo. Ao decorar uma propriedade com esse atributo, quando uma API é criada à partir dessa entidade, os end-points ListByTerm e FindByTerm passam a fazer consulta por termo nessa propriedade.

public class User : FluentEntity
{
    [Key]
    public int Code { get; set; }

    public string Email { get; set; }
    
    [Searchable]
    public string Name { get; set; }
}

Referência: O atributo SearchableAttribute pode ser utilizado por qualquer número de propriedades, porém, só deve ser utilizado em atributos do tipo String.

Pra prosseguir, veja o item Especificação