Para utilização do provider do Carol, precisamos instalar um pacote chamado Tnf.Provider.Carol disponível em nosso package source: https://www.myget.org/F/tnf/api/v3/index.json

Para começarmos a trabalhar temos que criar um projeto com suporte a .NET Core.

Para isso através do Visual Studio 2017 vamos criar nosso projeto acessando: File -> New -> Project -> .NET Standard -> Class Library.

Podemos agora começar a criar nossa entidade e repositórios para uso do Carol. Vamos começar com a definição de nosso módulo:

[DependsOn(
	typeof(DomainModule),
    typeof(TnfCarolModule))]
public class CarolModule : TnfModule
{
	public override void PreInitialize()
	{
		Configuration.Modules
			.TnfCarol()
			.Configure(new TnfCarolConfig()
			{
				ApplicationId = "21af0700038211e79daf4a8136534b63",
				TenantId = "8cd6e43115e9416eb23609486fa053e3",
				BaseAddress = "https://totvshealth.carol.ai/api/v1",
				Username = "[email protected]",
				Password = "password"
			});

		base.PreInitialize();
	}
	public override void Initialize()
	{
		IocManager.RegisterAssemblyByConvention(typeof(CarolModule).GetAssembly());
	}
}

Como podemos perceber na definição de nosso modulo, colocamos como dependência através do uso do atributo "DependsOn" a classe "TnfCarolModule" que fará a configuração de toda a infraestrutura do Carol para uso no assembly criado.

Agora podemos fazer uso da estrutura do Carol no TNF.

Definindo uma entidade

Para definir sua estrutura no Carol é preciso fazer sua especificação na declaração da entidade. Neste exemplo vamos criar uma entidade chamada "President":

[JsonObject("president")]
public class PresidentEntity : CarolEntity
{
	public string Name { get; set; }
	public string ZipCode { get; set; }
	public override object GetStagingMapping()
	{
		return new
		{
			name = "string",
			zipCode = "string"
		};
	}
}

Toda entidade do Carol deve herdar da classe CarolEntity fazendo a sobrescrita do método chamado GetStagingMapping, definindo assim a estrutura que o dado que será persistido dentro do Carol.

No Carol as entidades entram em sua infraestrutura como Staging. Após isso são criados modelos onde esses dados brutos (staging) serão mapeados para DataModels.

O uso do atributo JsonObject descreve o nome da entidade no Carol. Caso a classe que a represente não possua esse atributo o nome da classe será usado como referencia.

Consumindo dados

O pacote instalado Tnf.Provider.Carol prove alguns wrappers para utilização do Carol para operações de inserção, atualização, deleção e consulta de informações.

Essas funcionalidades estão disponíveis através do repositório CarolRepositoryBase<Entity>

Vamos criar um repositório para uso de nossa entidade chamado WhiteHouseRepository com a definição de sua interface:

public interface IWhiteHouseRepository : IRepository
{
	Task<PagingDtoResponse<PresidentDto>> GetAll(GellAllPresidentsRequestDto request);
    Task<PresidentDto> GetById(string id);
    Task<List<PresidentDto>> InsertAsync(List<PresidentDto> presidents, bool sync = false);
    Task UpdateAsync(PresidentDto president);
    Task DeleteAsync(string id);
}
 
public class WhiteHouseRepository : CarolRepositoryBase<PresidentEntity>, IWhiteHouseRepository
{
	public WhiteHouseRepository(ICarolClient client) :
		base(client)
	{
	}

	public async Task DeleteAsync(string id) => await DeleteAsync(id);
 
	public async Task<PagingDtoResponse<PresidentDto>> GetAll(GellAllPresidentsRequestDto request)
	{
		var response = new PagingDtoResponse<PresidentDto>();

		var query = Client.Queries<PresidentEntity>().ProcessFilter()
			.Offset(request.Offset)
			.PageSize(request.PageSize)
			.IndexType(Provider.Carol.Messages.ProcessFilter.IndexType.STAGING)
			.MustList((m) => m.TypeFilter()
							  .MatchFilter(p => p.Name, request.Name)
							  .TermFilter(p => p.ZipCode, request.ZipCode));

		var resultData = await GetAllAsync(query);
		response.Count = resultData.Count;
		response.Took = resultData.Took;
		response.TotalHits = resultData.TotalHits;
		resultData.Hits.ForEach((item) => response.Data.Add(new PresidentDto(item.Id, item.Name, item.ZipCode)));

		return response;
	}

	public async Task<PresidentDto> GetById(string id)
	{
		var presidentData = await GetAsync(id);
		var president = new PresidentDto(presidentData.Id, presidentData.Name, presidentData.ZipCode);
		return president;
	}

	public async Task<List<PresidentDto>> InsertAsync(List<PresidentDto> presidents, bool sync = false)
	{
		var presidentEntities = presidents.Select(s => new PresidentEntity()
		{
			Id = s.Id,
			Name = s.Name,
			ZipCode = s.ZipCode.Number
		}).ToList();

		presidentEntities = await InsertAsync(presidentEntities, sync);
		return presidents;
	}

	public async Task UpdateAsync(PresidentDto president)
	{
		await UpdateAsync(new PresidentEntity()
		{
			Id = president.Id,
			Name = president.Name,
			ZipCode = president.ZipCode.Number
		});
	}
}

Quando definimos o nosso repositório recebemos como parâmetro uma interface chamada ICarolClient. Esse tipo é injetado via dependência representando o client de conexão com o Carol.

Através dele será possível criar queries mais complexas ou acessar funcionalidades expostas dentro do provider. A herança do repositório do Carol já prove umas serie de métodos que facilitam a criação, atualização, deleção e consumo de serviço.

Para criar uma query por exemplo note que o método GetAll de nosso repositório realiza a construção da query através do objeto ICarolClient usando a função: Client.Queries<PresidentEntity>().ProcessFilter().

Esse método retorna uma interface de forma fluente onde é possível construir a query desejada. O método GetAllAsync do CarolRepositoryBase recebe o resultado dessa query criada retornando assim os registros que satisfazerem a sentença.

Note que no método InsertAsync o repositório do Carol recebe um parâmetro informando se a operação é síncrona ou assíncrona.

A diferença entre as operações é que a síncrona cria registro por registro na sequencia e espera o seu processamento pela interface de MDM (Master Data Management) do Carol.

Quando a operação é assíncrona os dados são inseridos em lote não esperando o seu processamento pelo MDM. Um processo posteriormente irá processar os registros pendentes no Carol.