diff --git a/OpenAdm.Api/Controllers/FaturaController.cs b/OpenAdm.Api/Controllers/FaturaController.cs
index 95ca389..1e93f85 100644
--- a/OpenAdm.Api/Controllers/FaturaController.cs
+++ b/OpenAdm.Api/Controllers/FaturaController.cs
@@ -17,55 +17,19 @@ namespace OpenAdm.Api.Controllers;
 [AutenticaParceiro]
 public class FaturaController : ControllerBase
 {
-    private readonly IParcelaService _faturaContasAReceberService;
+    private readonly IFaturaService _faturaService;
 
-    public FaturaController(IParcelaService faturaContasAReceberService)
+    public FaturaController(IFaturaService faturaService)
     {
-        _faturaContasAReceberService = faturaContasAReceberService;
+        _faturaService = faturaService;
     }
 
-    [HttpPost("paginacao")]
+    [HttpPost("criar")]
     [ProducesResponseType<PaginacaoViewModel<FaturaViewModel>>(200)]
     [ProducesResponseType<ErrorResponse>(400)]
-    public async Task<IActionResult> Paginacao(PaginacaoParcelaDto paginacaoFaturaAReceberDto)
+    public async Task<IActionResult> Criar(FaturaCriarAdmDto faturaCriarAdmDto)
     {
-        var paginacaoViewModel = await _faturaContasAReceberService.PaginacaoAsync(paginacaoFaturaAReceberDto);
-        return Ok(paginacaoViewModel);
-    }
-
-    [HttpGet("pedido")]
-    [ProducesResponseType<IList<FaturaViewModel>>(200)]
-    [ProducesResponseType<ErrorResponse>(400)]
-    public async Task<IActionResult> ByPedido([FromQuery] Guid pedidoId, [FromQuery] StatusParcelaEnum statusFatura)
-    {
-        var faturas = await _faturaContasAReceberService.GetByPedidoIdAsync(pedidoId, statusFatura);
-        return Ok(faturas);
-    }
-
-    [HttpGet("get-by-id")]
-    [ProducesResponseType<FaturaViewModel>(200)]
-    [ProducesResponseType<ErrorResponse>(400)]
-    public async Task<IActionResult> GetById([FromQuery] Guid id)
-    {
-        var fatura = await _faturaContasAReceberService.GetByIdAsync(id);
-        return Ok(fatura);
-    }
-
-    [HttpPut("pagar")]
-    [ProducesResponseType<FaturaViewModel>(200)]
-    [ProducesResponseType<ErrorResponse>(400)]
-    public async Task<IActionResult> Pagar(PagarParcelaDto pagarFaturaAReceberDto)
-    {
-        var fatura = await _faturaContasAReceberService.PagarAsync(pagarFaturaAReceberDto);
-        return Ok(fatura);
-    }
-
-    [HttpPut("edit")]
-    [ProducesResponseType<FaturaViewModel>(200)]
-    [ProducesResponseType<ErrorResponse>(400)]
-    public async Task<IActionResult> Edit(FaturaEdit faturaAReceberEdit)
-    {
-        var fatura = await _faturaContasAReceberService.EditAsync(faturaAReceberEdit);
-        return Ok(fatura);
+        var result = await _faturaService.CriarAdmAsync(faturaCriarAdmDto);
+        return Ok(result);
     }
 }
diff --git a/OpenAdm.Api/Controllers/ParcelaController.cs b/OpenAdm.Api/Controllers/ParcelaController.cs
new file mode 100644
index 0000000..9b6e2ba
--- /dev/null
+++ b/OpenAdm.Api/Controllers/ParcelaController.cs
@@ -0,0 +1,71 @@
+using Microsoft.AspNetCore.Mvc;
+using OpenAdm.Api.Attributes;
+using OpenAdm.Application.Dtos.FaturasDtos;
+using OpenAdm.Application.Dtos.Response;
+using OpenAdm.Application.Interfaces;
+using OpenAdm.Application.Models.ContasAReceberModel;
+using OpenAdm.Domain.Enuns;
+using OpenAdm.Domain.Model;
+using OpenAdm.Infra.Paginacao;
+
+namespace OpenAdm.Api.Controllers;
+
+[ApiController]
+[Route("parcela")]
+[IsFuncionario]
+[AutenticaParceiro]
+[Autentica]
+public class ParcelaController : ControllerBase
+{
+    private readonly IParcelaService _parcelaService;
+
+    public ParcelaController(IParcelaService parcelaService)
+    {
+        _parcelaService = parcelaService;
+    }
+
+    [HttpPost("paginacao")]
+    [ProducesResponseType<PaginacaoViewModel<FaturaViewModel>>(200)]
+    [ProducesResponseType<ErrorResponse>(400)]
+    public async Task<IActionResult> Paginacao(PaginacaoParcelaDto paginacaoFaturaAReceberDto)
+    {
+        var paginacaoViewModel = await _parcelaService.PaginacaoAsync(paginacaoFaturaAReceberDto);
+        return Ok(paginacaoViewModel);
+    }
+
+    [HttpGet("pedido")]
+    [ProducesResponseType<IList<FaturaViewModel>>(200)]
+    [ProducesResponseType<ErrorResponse>(400)]
+    public async Task<IActionResult> ByPedido([FromQuery] Guid pedidoId, [FromQuery] StatusParcelaEnum statusFatura)
+    {
+        var faturas = await _parcelaService.GetByPedidoIdAsync(pedidoId, statusFatura);
+        return Ok(faturas);
+    }
+
+    [HttpGet("get-by-id")]
+    [ProducesResponseType<FaturaViewModel>(200)]
+    [ProducesResponseType<ErrorResponse>(400)]
+    public async Task<IActionResult> GetById([FromQuery] Guid id)
+    {
+        var fatura = await _parcelaService.GetByIdAsync(id);
+        return Ok(fatura);
+    }
+
+    [HttpPut("pagar")]
+    [ProducesResponseType<FaturaViewModel>(200)]
+    [ProducesResponseType<ErrorResponse>(400)]
+    public async Task<IActionResult> Pagar(PagarParcelaDto pagarFaturaAReceberDto)
+    {
+        var fatura = await _parcelaService.PagarAsync(pagarFaturaAReceberDto);
+        return Ok(fatura);
+    }
+
+    [HttpPut("edit")]
+    [ProducesResponseType<FaturaViewModel>(200)]
+    [ProducesResponseType<ErrorResponse>(400)]
+    public async Task<IActionResult> Edit(FaturaEdit faturaAReceberEdit)
+    {
+        var fatura = await _parcelaService.EditAsync(faturaAReceberEdit);
+        return Ok(fatura);
+    }
+}
diff --git a/OpenAdm.Api/Controllers/UsuarioController.cs b/OpenAdm.Api/Controllers/UsuarioController.cs
index b08ad6b..a57267b 100644
--- a/OpenAdm.Api/Controllers/UsuarioController.cs
+++ b/OpenAdm.Api/Controllers/UsuarioController.cs
@@ -51,6 +51,15 @@ public async Task<IActionResult> GetContaAdm(Guid id)
         return Ok(usuarioViewModel);
     }
 
+    [Autentica]
+    [IsFuncionario]
+    [HttpPost("paginacao-drop-down")]
+    public async Task<IActionResult> PaginacaoDropDown(PaginacaoUsuarioDropDown paginacaoUsuarioDropDown)
+    {
+        var usuarioViewModel = await _usuarioService.PaginacaoDropDownAsync(paginacaoUsuarioDropDown);
+        return Ok(usuarioViewModel);
+    }
+
     [Autentica]
     [IsFuncionario]
     [HttpGet("list")]
diff --git a/OpenAdm.Application/Dtos/FaturasDtos/FaturaCriarAdmDto.cs b/OpenAdm.Application/Dtos/FaturasDtos/FaturaCriarAdmDto.cs
new file mode 100644
index 0000000..5829ff2
--- /dev/null
+++ b/OpenAdm.Application/Dtos/FaturasDtos/FaturaCriarAdmDto.cs
@@ -0,0 +1,26 @@
+using OpenAdm.Domain.Enuns;
+using OpenAdm.Domain.Exceptions;
+
+namespace OpenAdm.Application.Dtos.FaturasDtos;
+
+public class FaturaCriarAdmDto
+{
+    public Guid UsuarioId { get; set; }
+    public Guid? PedidoId { get; set; }
+    public TipoFaturaEnum Tipo { get; set; }
+    public IList<ParcelaCriarAdmDto> Parcelas { get; set; } = [];
+
+    public void Validar()
+    {
+        if (Parcelas.Count == 0)
+        {
+            throw new ExceptionApi("Informe as parcelas!");
+        }
+
+        var temParcelaZerada = Parcelas.Any(x => x.Valor == 0);
+        if (temParcelaZerada)
+        {
+            throw new ExceptionApi("Não é possível informar parcelas com o valor zero!");
+        }
+    }
+}
diff --git a/OpenAdm.Application/Dtos/FaturasDtos/ParcelaCriarAdmDto.cs b/OpenAdm.Application/Dtos/FaturasDtos/ParcelaCriarAdmDto.cs
new file mode 100644
index 0000000..b86afb0
--- /dev/null
+++ b/OpenAdm.Application/Dtos/FaturasDtos/ParcelaCriarAdmDto.cs
@@ -0,0 +1,13 @@
+using OpenAdm.Domain.Enuns;
+
+namespace OpenAdm.Application.Dtos.FaturasDtos;
+
+public class ParcelaCriarAdmDto
+{
+    public DateTime DataDeVencimento { get; set; }
+    public int NumeroDaFatura { get; set; }
+    public MeioDePagamentoEnum? MeioDePagamento { get; set; }
+    public decimal Valor { get; set; }
+    public decimal? Desconto { get; set; }
+    public string? Observacao { get; set; }
+}
diff --git a/OpenAdm.Application/Interfaces/IFaturaService.cs b/OpenAdm.Application/Interfaces/IFaturaService.cs
index c45f936..1a05241 100644
--- a/OpenAdm.Application/Interfaces/IFaturaService.cs
+++ b/OpenAdm.Application/Interfaces/IFaturaService.cs
@@ -1,4 +1,5 @@
 using OpenAdm.Application.Dtos.FaturasDtos;
+using OpenAdm.Application.Models.ContasAReceberModel;
 using OpenAdm.Application.Models.Pagamentos;
 using OpenAdm.Domain.Enuns;
 
@@ -9,4 +10,5 @@ public interface IFaturaService
     Task CriarContasAReceberAsync(CriarFaturaDto contasAReceberDto);
     Task VerificarFechamentoAsync(Guid id);
     Task<PagamentoViewModel> GerarPagamentoAsync(MeioDePagamentoEnum meioDePagamento, Guid pedidoId);
+    Task<FaturaViewModel> CriarAdmAsync(FaturaCriarAdmDto faturaCriarAdmDto);
 }
diff --git a/OpenAdm.Application/Interfaces/IUsuarioService.cs b/OpenAdm.Application/Interfaces/IUsuarioService.cs
index 598e66c..31bd31c 100644
--- a/OpenAdm.Application/Interfaces/IUsuarioService.cs
+++ b/OpenAdm.Application/Interfaces/IUsuarioService.cs
@@ -15,4 +15,5 @@ public interface IUsuarioService
     Task<ResponseLoginUsuarioViewModel> UpdateUsuarioAsync(UpdateUsuarioDto updateUsuarioDto);
     Task TrocarSenhaAsync(UpdateSenhaUsuarioDto updateSenhaUsuarioDto);
     Task<PaginacaoViewModel<UsuarioViewModel>> PaginacaoAsync(PaginacaoUsuarioDto paginacaoUsuarioDto);
+    Task<IList<UsuarioViewModel>> PaginacaoDropDownAsync(PaginacaoUsuarioDropDown paginacaoUsuarioDropDown);
 }
diff --git a/OpenAdm.Application/Services/FaturaService.cs b/OpenAdm.Application/Services/FaturaService.cs
index 0c875d9..198aba0 100644
--- a/OpenAdm.Application/Services/FaturaService.cs
+++ b/OpenAdm.Application/Services/FaturaService.cs
@@ -1,5 +1,6 @@
 using OpenAdm.Application.Dtos.FaturasDtos;
 using OpenAdm.Application.Interfaces;
+using OpenAdm.Application.Models.ContasAReceberModel;
 using OpenAdm.Application.Models.Pagamentos;
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Enuns;
@@ -13,15 +14,57 @@ public sealed class FaturaService : IFaturaService
     private readonly IFaturaRepository _contasAReceberRepository;
     private readonly IPagamentoFactory _pagamentoFactory;
     private readonly IUsuarioAutenticado _usuarioAutenticado;
+    private readonly IUsuarioService _usuarioService;
 
     public FaturaService(
         IFaturaRepository contasAReceberRepository,
         IPagamentoFactory pagamentoFactory,
-        IUsuarioAutenticado usuarioAutenticado)
+        IUsuarioAutenticado usuarioAutenticado,
+        IUsuarioService usuarioService)
     {
         _contasAReceberRepository = contasAReceberRepository;
         _pagamentoFactory = pagamentoFactory;
         _usuarioAutenticado = usuarioAutenticado;
+        _usuarioService = usuarioService;
+    }
+
+    public async Task<FaturaViewModel> CriarAdmAsync(FaturaCriarAdmDto faturaCriarAdmDto)
+    {
+        _ = await _usuarioService.GetUsuarioByIdAdmAsync(id: faturaCriarAdmDto.UsuarioId);
+
+        var fatura = new Fatura(
+            id: Guid.NewGuid(),
+            dataDeCriacao: DateTime.Now,
+            dataDeAtualizacao: DateTime.Now,
+            numero: 0,
+            status: StatusFaturaEnum.Aberta,
+            usuarioId: faturaCriarAdmDto.UsuarioId,
+            pedidoId: faturaCriarAdmDto.PedidoId,
+            dataDeFechamento: null,
+            tipo: faturaCriarAdmDto.Tipo);
+
+        foreach (var parcelaDto in faturaCriarAdmDto.Parcelas)
+        {
+            fatura.Parcelas.Add(new Parcela(
+                id: Guid.NewGuid(),
+                dataDeCriacao: DateTime.Now,
+                dataDeAtualizacao: DateTime.Now,
+                numero: 0,
+                status: StatusParcelaEnum.Pendente,
+                dataDeVencimento: parcelaDto.DataDeVencimento,
+                numeroDaFatura: parcelaDto.NumeroDaFatura,
+                meioDePagamento: parcelaDto.MeioDePagamento,
+                valor: parcelaDto.Valor,
+                desconto: parcelaDto.Desconto,
+                observacao: parcelaDto.Observacao,
+                faturaId: fatura.Id,
+                dataDePagamento: null,
+                idExterno: null));
+        }
+
+        await _contasAReceberRepository.AddAsync(fatura);
+
+        return (FaturaViewModel)fatura;
     }
 
     public async Task CriarContasAReceberAsync(CriarFaturaDto contasAReceberDto)
diff --git a/OpenAdm.Application/Services/ParcelaService.cs b/OpenAdm.Application/Services/ParcelaService.cs
index d942698..8aa97ca 100644
--- a/OpenAdm.Application/Services/ParcelaService.cs
+++ b/OpenAdm.Application/Services/ParcelaService.cs
@@ -71,7 +71,7 @@ public async Task<ParcelaViewModel> EditAsync(FaturaEdit faturaAReceberEdit)
 
     public async Task<IList<ParcelaPagaDashBoardModel>> FaturasDashBoardAsync()
     {
-        var faturas = await _faturaContasAReceberRepository.SumMesesAsync();
+        var faturas = await _faturaContasAReceberRepository.SumTotalMesesAsync(TipoFaturaEnum.A_Receber);
         var faturasPagaDashBoardModel = new List<ParcelaPagaDashBoardModel>();
         foreach (var item in faturas)
         {
@@ -99,7 +99,7 @@ public async Task<IList<ParcelaViewModel>> GetByPedidoIdAsync(Guid pedidoId, Sta
     }
 
     public Task<decimal> GetSumAReceberAsync()
-        => _faturaContasAReceberRepository.SumAReceberAsync();
+        => _faturaContasAReceberRepository.SumTotalAsync(TipoFaturaEnum.A_Receber);
 
     public async Task<ParcelaViewModel> PagarAsync(PagarParcelaDto pagarFaturaAReceberDto)
     {
diff --git a/OpenAdm.Application/Services/UsuarioService.cs b/OpenAdm.Application/Services/UsuarioService.cs
index 4141816..e543679 100644
--- a/OpenAdm.Application/Services/UsuarioService.cs
+++ b/OpenAdm.Application/Services/UsuarioService.cs
@@ -152,4 +152,15 @@ public async Task<ResponseLoginUsuarioViewModel> UpdateUsuarioAsync(UpdateUsuari
 
         return new(usuarioViewModel, token, refreshToken);
     }
+
+    public async Task<IList<UsuarioViewModel>> PaginacaoDropDownAsync(PaginacaoUsuarioDropDown paginacaoUsuarioDropDown)
+    {
+        var usuarios = await _usuarioRepository.PaginacaoDropDownAsync(paginacaoUsuarioDropDown);
+        return usuarios.Select(x => new UsuarioViewModel()
+        {
+            Cnpj = string.IsNullOrWhiteSpace(x.Cnpj) ? x.Cpf : x.Cnpj,
+            Id = x.Id,
+            Nome = x.Nome
+        }).ToList();
+    }
 }
diff --git a/OpenAdm.Domain/Interfaces/IGenericRepository.cs b/OpenAdm.Domain/Interfaces/IGenericRepository.cs
index 05e0952..5d1c736 100644
--- a/OpenAdm.Domain/Interfaces/IGenericRepository.cs
+++ b/OpenAdm.Domain/Interfaces/IGenericRepository.cs
@@ -1,5 +1,5 @@
-using OpenAdm.Domain.Entities.Bases;
-using OpenAdm.Domain.Model;
+using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 
 namespace OpenAdm.Domain.Interfaces;
 
@@ -9,4 +9,5 @@ public interface IGenericRepository<T> where T : class
     Task<T> UpdateAsync(T entity);
     Task<bool> DeleteAsync(T entity);
     Task<PaginacaoViewModel<T>> PaginacaoAsync(FilterModel<T> filterModel);
+    Task<IList<T>> PaginacaoDropDownAsync(PaginacaoDropDown<T> paginacaoDropDown);
 }
diff --git a/OpenAdm.Domain/Interfaces/IParcelaRepository.cs b/OpenAdm.Domain/Interfaces/IParcelaRepository.cs
index d2f7995..8fc6117 100644
--- a/OpenAdm.Domain/Interfaces/IParcelaRepository.cs
+++ b/OpenAdm.Domain/Interfaces/IParcelaRepository.cs
@@ -5,8 +5,8 @@ namespace OpenAdm.Domain.Interfaces;
 
 public interface IParcelaRepository : IGenericRepository<Parcela>
 {
-    Task<decimal> SumAReceberAsync();
-    Task<IDictionary<int, decimal>> SumMesesAsync();
+    Task<decimal> SumTotalAsync(TipoFaturaEnum faturaEnum);
+    Task<IDictionary<int, decimal>> SumTotalMesesAsync(TipoFaturaEnum faturaEnum);
     Task<Parcela?> GetByIdAsync(Guid id);
     Task<Parcela?> GetByIdExternoAsync(string idExterno);
     Task<IList<Parcela>> GetByPedidoIdAsync(Guid pedidoId, StatusParcelaEnum? statusFaturaContasAReceberEnum);
diff --git a/OpenAdm.Domain/PaginateDto/PaginacaoDropDown.cs b/OpenAdm.Domain/PaginateDto/PaginacaoDropDown.cs
new file mode 100644
index 0000000..d6e4caf
--- /dev/null
+++ b/OpenAdm.Domain/PaginateDto/PaginacaoDropDown.cs
@@ -0,0 +1,11 @@
+using System.Linq.Expressions;
+
+namespace OpenAdm.Domain.PaginateDto;
+
+public abstract class PaginacaoDropDown<T> where T : class
+{
+    public string? Search { get; set; }
+    public string OrderBy { get; set; } = "DataDeAtualizacao";
+
+    public abstract Expression<Func<T, bool>>? Where();
+}
diff --git a/OpenAdm.Infra/Cached/Cached/BannerCached.cs b/OpenAdm.Infra/Cached/Cached/BannerCached.cs
index 36b5a10..04f1ba8 100644
--- a/OpenAdm.Infra/Cached/Cached/BannerCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/BannerCached.cs
@@ -1,6 +1,7 @@
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Interfaces;
 using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 using OpenAdm.Infra.Cached.Interfaces;
 using OpenAdm.Infra.Repositories;
 
@@ -77,4 +78,7 @@ public async Task<Banner> UpdateAsync(Banner entity)
 
     public Task<PaginacaoViewModel<Banner>> PaginacaoAsync(FilterModel<Banner> filterModel)
         => _bannerRepository.PaginacaoAsync(filterModel);
+
+    public Task<IList<Banner>> PaginacaoDropDownAsync(PaginacaoDropDown<Banner> paginacaoDropDown)
+        => _bannerRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/CategoriaCached.cs b/OpenAdm.Infra/Cached/Cached/CategoriaCached.cs
index abf9701..7877bb1 100644
--- a/OpenAdm.Infra/Cached/Cached/CategoriaCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/CategoriaCached.cs
@@ -1,6 +1,7 @@
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Interfaces;
 using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 using OpenAdm.Infra.Cached.Interfaces;
 using OpenAdm.Infra.Repositories;
 
@@ -73,4 +74,7 @@ public Task<PaginacaoViewModel<Categoria>> GetPaginacaoCategoriaAsync(FilterMode
 
     public Task<PaginacaoViewModel<Categoria>> PaginacaoAsync(FilterModel<Categoria> filterModel)
         => _categoriaRepository.PaginacaoAsync(filterModel);
+
+    public Task<IList<Categoria>> PaginacaoDropDownAsync(PaginacaoDropDown<Categoria> paginacaoDropDown)
+        => _categoriaRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/ConfiguracaoDeEmailCached.cs b/OpenAdm.Infra/Cached/Cached/ConfiguracaoDeEmailCached.cs
index 8a3944f..ad1c436 100644
--- a/OpenAdm.Infra/Cached/Cached/ConfiguracaoDeEmailCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/ConfiguracaoDeEmailCached.cs
@@ -3,11 +3,12 @@
 using OpenAdm.Infra.Repositories;
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 
 namespace OpenAdm.Infra.Cached.Cached;
 
 public class ConfiguracaoDeEmailCached(
-    ConfiguracaoDeEmailRepository configuracaoDeEmailRepository, 
+    ConfiguracaoDeEmailRepository configuracaoDeEmailRepository,
     ICachedService<ConfiguracaoDeEmail> cachedService) : IConfiguracaoDeEmailRepository
 {
     private readonly ConfiguracaoDeEmailRepository _configuracaoDeEmailRepository = configuracaoDeEmailRepository;
@@ -33,11 +34,11 @@ public async Task<bool> DeleteAsync(ConfiguracaoDeEmail entity)
 
         var configuracao = await _cachedService.GetItemAsync(key);
 
-        if(configuracao == null)
+        if (configuracao == null)
         {
             configuracao = await _configuracaoDeEmailRepository.GetConfiguracaoDeEmailAtivaAsync();
 
-            if(configuracao != null)
+            if (configuracao != null)
             {
                 await _cachedService.SetItemAsync(key, configuracao);
             }
@@ -55,4 +56,7 @@ public async Task<ConfiguracaoDeEmail> UpdateAsync(ConfiguracaoDeEmail entity)
 
     public Task<PaginacaoViewModel<ConfiguracaoDeEmail>> PaginacaoAsync(FilterModel<ConfiguracaoDeEmail> filterModel)
         => _configuracaoDeEmailRepository.PaginacaoAsync(filterModel);
+
+    public Task<IList<ConfiguracaoDeEmail>> PaginacaoDropDownAsync(PaginacaoDropDown<ConfiguracaoDeEmail> paginacaoDropDown)
+        => _configuracaoDeEmailRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/ConfiguracoesDePedidoCached.cs b/OpenAdm.Infra/Cached/Cached/ConfiguracoesDePedidoCached.cs
index ba3bc82..ea91f97 100644
--- a/OpenAdm.Infra/Cached/Cached/ConfiguracoesDePedidoCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/ConfiguracoesDePedidoCached.cs
@@ -3,6 +3,7 @@
 using OpenAdm.Infra.Repositories;
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 
 namespace OpenAdm.Infra.Cached.Cached;
 
@@ -13,7 +14,7 @@ public class ConfiguracoesDePedidoCached : IConfiguracoesDePedidoRepository
     private const string _key = "configuracao-de-pedido";
 
     public ConfiguracoesDePedidoCached(
-        ConfiguracoesDePedidoRepository configuracoesDePedidoRepository, 
+        ConfiguracoesDePedidoRepository configuracoesDePedidoRepository,
         ICachedService<ConfiguracoesDePedido> cachedService)
     {
         _configuracoesDePedidoRepository = configuracoesDePedidoRepository;
@@ -36,11 +37,11 @@ public async Task<bool> DeleteAsync(ConfiguracoesDePedido entity)
     {
         var configuracao = await _cachedService.GetItemAsync(_key);
 
-        if(configuracao == null)
+        if (configuracao == null)
         {
             configuracao = await _configuracoesDePedidoRepository.GetConfiguracoesDePedidoAsync();
 
-            if(configuracao != null)
+            if (configuracao != null)
             {
                 await _cachedService.SetItemAsync(_key, configuracao);
             }
@@ -57,4 +58,7 @@ public async Task<ConfiguracoesDePedido> UpdateAsync(ConfiguracoesDePedido entit
 
     public Task<PaginacaoViewModel<ConfiguracoesDePedido>> PaginacaoAsync(FilterModel<ConfiguracoesDePedido> filterModel)
         => _configuracoesDePedidoRepository.PaginacaoAsync(filterModel);
+
+    public Task<IList<ConfiguracoesDePedido>> PaginacaoDropDownAsync(PaginacaoDropDown<ConfiguracoesDePedido> paginacaoDropDown)
+        => _configuracoesDePedidoRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/PedidoCached.cs b/OpenAdm.Infra/Cached/Cached/PedidoCached.cs
index 0aacdb9..e4b86f4 100644
--- a/OpenAdm.Infra/Cached/Cached/PedidoCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/PedidoCached.cs
@@ -3,6 +3,7 @@
 using OpenAdm.Domain.Interfaces;
 using OpenAdm.Domain.Model;
 using OpenAdm.Domain.Model.Pedidos;
+using OpenAdm.Domain.PaginateDto;
 using OpenAdm.Infra.Cached.Interfaces;
 using OpenAdm.Infra.Repositories;
 
@@ -101,4 +102,7 @@ public async Task<Pedido> UpdateAsync(Pedido entity)
         await _cachedService.RemoveCachedAsync(key);
         return await _pedidoRepository.UpdateAsync(entity);
     }
+
+    public Task<IList<Pedido>> PaginacaoDropDownAsync(PaginacaoDropDown<Pedido> paginacaoDropDown)
+        => _pedidoRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/PesoCached.cs b/OpenAdm.Infra/Cached/Cached/PesoCached.cs
index d9c48b3..4c05a16 100644
--- a/OpenAdm.Infra/Cached/Cached/PesoCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/PesoCached.cs
@@ -1,6 +1,7 @@
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Interfaces;
 using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 using OpenAdm.Infra.Cached.Interfaces;
 using OpenAdm.Infra.Repositories;
 
@@ -93,4 +94,7 @@ public Task<PaginacaoViewModel<Peso>> PaginacaoAsync(FilterModel<Peso> filterMod
 
     public Task<IDictionary<Guid, Peso>> GetDictionaryPesosByIdsAsync(IList<Guid> ids)
         => _pesoRepository.GetDictionaryPesosByIdsAsync(ids);
+
+    public Task<IList<Peso>> PaginacaoDropDownAsync(PaginacaoDropDown<Peso> paginacaoDropDown)
+        => _pesoRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/ProdutoCached.cs b/OpenAdm.Infra/Cached/Cached/ProdutoCached.cs
index 1240b78..a2864d0 100644
--- a/OpenAdm.Infra/Cached/Cached/ProdutoCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/ProdutoCached.cs
@@ -174,4 +174,7 @@ public Task<IDictionary<Guid, Produto>> GetDictionaryProdutosAsync(IList<Guid> i
 
     public Task<PaginacaoViewModel<Produto>> PaginacaoAsync(FilterModel<Produto> filterModel)
         => _produtoRepository.PaginacaoAsync(filterModel);
+
+    public Task<IList<Produto>> PaginacaoDropDownAsync(PaginacaoDropDown<Produto> paginacaoDropDown)
+        => _produtoRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/TamanhoCached.cs b/OpenAdm.Infra/Cached/Cached/TamanhoCached.cs
index b6b7c96..46c9cca 100644
--- a/OpenAdm.Infra/Cached/Cached/TamanhoCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/TamanhoCached.cs
@@ -1,6 +1,7 @@
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Interfaces;
 using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 using OpenAdm.Infra.Cached.Interfaces;
 using OpenAdm.Infra.Repositories;
 
@@ -93,4 +94,7 @@ public Task<PaginacaoViewModel<Tamanho>> PaginacaoAsync(FilterModel<Tamanho> fil
 
     public Task<IDictionary<Guid, Tamanho>> GetDictionaryTamanhosAsync(IList<Guid> ids)
         => _tamanhoRepository.GetDictionaryTamanhosAsync(ids);
+
+    public Task<IList<Tamanho>> PaginacaoDropDownAsync(PaginacaoDropDown<Tamanho> paginacaoDropDown)
+        => _tamanhoRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Cached/Cached/UsuarioCached.cs b/OpenAdm.Infra/Cached/Cached/UsuarioCached.cs
index 3cc73fa..b9e5ae6 100644
--- a/OpenAdm.Infra/Cached/Cached/UsuarioCached.cs
+++ b/OpenAdm.Infra/Cached/Cached/UsuarioCached.cs
@@ -3,6 +3,7 @@
 using OpenAdm.Infra.Repositories;
 using OpenAdm.Domain.Entities;
 using OpenAdm.Domain.Model;
+using OpenAdm.Domain.PaginateDto;
 
 namespace OpenAdm.Infra.Cached.Cached;
 
@@ -84,4 +85,7 @@ public Task<PaginacaoViewModel<Usuario>> GetPaginacaoAsync(FilterModel<Usuario>
 
     public Task<PaginacaoViewModel<Usuario>> PaginacaoAsync(FilterModel<Usuario> filterModel)
         => _usuarioRepository.PaginacaoAsync(filterModel);
+
+    public Task<IList<Usuario>> PaginacaoDropDownAsync(PaginacaoDropDown<Usuario> paginacaoDropDown)
+        => _usuarioRepository.PaginacaoDropDownAsync(paginacaoDropDown);
 }
diff --git a/OpenAdm.Infra/Migrations/Parceiro/20240621003728_InitParceiroContextMigration.cs b/OpenAdm.Infra/Migrations/Parceiro/20240621003728_InitParceiroContextMigration.cs
index 89ef788..838bc5e 100644
--- a/OpenAdm.Infra/Migrations/Parceiro/20240621003728_InitParceiroContextMigration.cs
+++ b/OpenAdm.Infra/Migrations/Parceiro/20240621003728_InitParceiroContextMigration.cs
@@ -12,6 +12,7 @@ public partial class InitParceiroContextMigration : Migration
         /// <inheritdoc />
         protected override void Up(MigrationBuilder migrationBuilder)
         {
+            migrationBuilder.Sql("CREATE EXTENSION IF NOT EXISTS \"unaccent\";");
             migrationBuilder.CreateTable(
                 name: "Banners",
                 columns: table => new
diff --git a/OpenAdm.Infra/Paginacao/PaginacaoUsuarioDropDown.cs b/OpenAdm.Infra/Paginacao/PaginacaoUsuarioDropDown.cs
new file mode 100644
index 0000000..650f00c
--- /dev/null
+++ b/OpenAdm.Infra/Paginacao/PaginacaoUsuarioDropDown.cs
@@ -0,0 +1,19 @@
+using Microsoft.EntityFrameworkCore;
+using OpenAdm.Domain.Entities;
+using OpenAdm.Domain.PaginateDto;
+using System.Linq.Expressions;
+
+namespace OpenAdm.Infra.Paginacao;
+
+public class PaginacaoUsuarioDropDown : PaginacaoDropDown<Usuario>
+{
+    public override Expression<Func<Usuario, bool>>? Where()
+    {
+        if (string.IsNullOrWhiteSpace(Search))
+        {
+            return null;
+        }
+
+        return x => EF.Functions.ILike(EF.Functions.Unaccent(x.Nome), $"%{Search}%");
+    }
+}
diff --git a/OpenAdm.Infra/Repositories/GenericRepository.cs b/OpenAdm.Infra/Repositories/GenericRepository.cs
index 7003e73..265cde6 100644
--- a/OpenAdm.Infra/Repositories/GenericRepository.cs
+++ b/OpenAdm.Infra/Repositories/GenericRepository.cs
@@ -4,6 +4,7 @@
 using OpenAdm.Domain.Model;
 using Microsoft.EntityFrameworkCore;
 using OpenAdm.Infra.Extensions.IQueryable;
+using OpenAdm.Domain.PaginateDto;
 
 namespace OpenAdm.Infra.Repositories;
 
@@ -71,6 +72,18 @@ public virtual async Task<PaginacaoViewModel<T>> PaginacaoAsync(FilterModel<T> f
         };
     }
 
+    public async Task<IList<T>> PaginacaoDropDownAsync(PaginacaoDropDown<T> paginacaoDropDown)
+    {
+        return await _parceiroContext
+            .Set<T>()
+            .AsNoTracking()
+            .OrderBy(x => EF.Property<T>(x, paginacaoDropDown.OrderBy))
+            .WhereIsNotNull(paginacaoDropDown.Where())
+            .Skip(0)
+            .Take(100)
+            .ToListAsync();
+    }
+
     public async Task<T> UpdateAsync(T entity)
     {
         _parceiroContext.Attach(entity);
diff --git a/OpenAdm.Infra/Repositories/ParcelaRepository.cs b/OpenAdm.Infra/Repositories/ParcelaRepository.cs
index b60b8c5..92e9934 100644
--- a/OpenAdm.Infra/Repositories/ParcelaRepository.cs
+++ b/OpenAdm.Infra/Repositories/ParcelaRepository.cs
@@ -46,14 +46,15 @@ public async Task<IList<Parcela>> GetByPedidoIdAsync(Guid pedidoId, StatusParcel
             .ToListAsync();
     }
 
-    public async Task<decimal> SumAReceberAsync()
+    public async Task<decimal> SumTotalAsync(TipoFaturaEnum tipoFatura)
     {
         try
         {
             return await _parceiroContext
                 .Parcelas
                 .AsNoTracking()
-                .Where(x => x.Status == StatusParcelaEnum.Pendente)
+                .Include(x => x.Fatura)
+                .Where(x => x.Status == StatusParcelaEnum.Pendente && x.Fatura.Tipo == tipoFatura)
                 .SumAsync(x => x.Valor);
         }
         catch (Exception)
@@ -62,7 +63,7 @@ public async Task<decimal> SumAReceberAsync()
         }
     }
 
-    public async Task<IDictionary<int, decimal>> SumMesesAsync()
+    public async Task<IDictionary<int, decimal>> SumTotalMesesAsync(TipoFaturaEnum faturaEnum)
     {
         var dataInicio = DateTime.Now.AddMonths(-3);
         var dataSplit = dataInicio.ToString("MM/dd/yyyy").Split('/');
@@ -72,7 +73,11 @@ public async Task<IDictionary<int, decimal>> SumMesesAsync()
         return await _parceiroContext
             .Parcelas
             .AsNoTracking()
-            .Where(m => m.DataDeCriacao.Month >= mes && m.DataDeCriacao.Year == ano && m.Status == StatusParcelaEnum.Pago)
+            .Include(x => x.Fatura)
+            .Where(m => m.DataDeCriacao.Month >= mes &&
+                m.DataDeCriacao.Year == ano &&
+                m.Status == StatusParcelaEnum.Pago &&
+                m.Fatura.Tipo == faturaEnum)
             .GroupBy(m => m.DataDeCriacao.Month)
             .ToDictionaryAsync(
                 g => g.Key,