public async Task <ActionResult <Contrato> > Post(
[FromServices] DataContext context,
[FromBody] Contrato model)
{
if (ModelState.IsValid)
{
context.Contratos.Add(model);
await context.SaveChangesAsync();
var valor = (model.ValorFinanciado / model.Parcelas);
for (int i = 0; i < model.Parcelas; i++)
{
int vencimento = i + 1;
Prestacao prestacao = new Prestacao();
prestacao.Valor = valor;
prestacao.ContratoId = model.Id;
prestacao.DataVencimento = DateTime.Today.AddMonths(vencimento);
context.Prestacoes.Add(prestacao);
}
await context.SaveChangesAsync();
return(model);
}
else
{
return(BadRequest(ModelState));
}
}
static void Main(string[] args)
{
// classes originais
var prestacao = new Prestacao();
var valor = prestacao.Calcular(10000m, 100);
Console.WriteLine("Valor calculado: {0:C}", valor);
var prestacaoContratoEspecial = new PrestacaoContratoEspecial();
valor = prestacaoContratoEspecial.Calcular(10000m, 100);
Console.WriteLine("Valor calculado: {0:C}", valor);
// classes refatoradas
var prestacaoRefatorada = new Refatorado.Prestacao();
valor = prestacaoRefatorada.Calcular(10000m, 100);
Console.WriteLine("Valor calculado: {0:C}", valor);
var prestacaoRefatoradaEspecial = new Refatorado.PrestacaoContratoEspecial();
valor = prestacaoRefatoradaEspecial.Calcular(10000m, 100);
Console.WriteLine("Valor calculado: {0:C}", valor);
// classes com o padrao TemplateMethod
var prestacaoPadrao = new TemplateMethod.PrestacaoContratoPadrao();
valor = prestacaoPadrao.Calcular(10000m, 100);
Console.WriteLine("Valor calculado: {0:C}", valor);
var prestacaoEspecial = new TemplateMethod.PrestacaoContratoEspecial();
valor = prestacaoEspecial.Calcular(10000m, 100);
Console.WriteLine("Valor calculado: {0:C}", valor);
Console.ReadKey();
}
public SaldoEmprestimo GerarSaldo(Prestacao pPrestacao)
{
if (pPrestacao.Id < 1)
{
throw new OperacaoNaoRealizadaException();
}
if (pPrestacao.Contrato == null)
{
throw new CampoNaoInformadoException("Saldo", "Contrato", true);
}
SaldoEmprestimo lSaldo = new SaldoEmprestimo();
lSaldo.Contrato = pPrestacao.Contrato;
lSaldo.Correcao = pPrestacao.ValorCorrecao;
lSaldo.DataReferencia = pPrestacao.DataVencimento.Value;
lSaldo.Prestacao = pPrestacao;
Contrato lContrato = pPrestacao.Contrato;
foreach (Prestacao lPrestacao in lContrato.Prestacoes)
{
if (lPrestacao.NumeroPrestacao <= pPrestacao.NumeroPrestacao)
{
lSaldo.SaldoPrincipal += lPrestacao.ValorPrestacao;
}
if (lPrestacao.DataPagamento == null)
{
lSaldo.SaldoDevedorTotal += lPrestacao.ValorPrestacao;
}
}
lSaldo.SaldoDevedorTotal -= lSaldo.Prestacao.ValorPrestacao;
return(lSaldo);
}
public async Task <ActionResult <Contrato> > Post([FromServices] DataContext context, [FromBody] Contrato model)
{
if (ModelState.IsValid && model.Id == 0)
{
context.Contratos.Add(model);
long valorPrestacoes = model.ValorFianciado / model.QuantidadeParcelas;
DateTime dataProximaPrestacao;
if (model.DataContratacao == DateTime.MinValue)
{
dataProximaPrestacao = DateTime.Now.AddDays(30);
}
else
{
dataProximaPrestacao = model.DataContratacao.AddDays(30);
}
for (int i = 1; i <= model.QuantidadeParcelas; i++)
{
Prestacao p = new Prestacao();
p.ContratoId = model.Id;
p.Valor = valorPrestacoes;
p.DataVencimento = dataProximaPrestacao;
context.Prestacoes_Contrato.Add(p);
dataProximaPrestacao = dataProximaPrestacao.AddDays(30);
}
await context.SaveChangesAsync();
return(model);
}
else
{
return(BadRequest(ModelState));
}
}
public bool EnviarEmail(Prestacao prestacao, PrestacaoStatuses statusAtual, string emailTo)
{
try
{
var mail = new MailMessage
{
From = new MailAddress(_emailSettings.FromEmail, "PrestaSys")
};
mail.To.Add(new MailAddress(emailTo));
mail.Subject = "PrestaSys - Prestação de Contas - " + prestacao.Titulo;
mail.Body = GetEmailBody(prestacao, statusAtual);
mail.IsBodyHtml = true;
mail.Priority = MailPriority.High;
using (var smtp = new SmtpClient(_emailSettings.PrimaryDomain, _emailSettings.PrimaryPort))
{
smtp.Credentials =
new NetworkCredential(_emailSettings.UsernameEmail, _emailSettings.UsernamePassword);
smtp.EnableSsl = true;
if (!_environment.IsDevelopment())
{
smtp.Send(mail);
}
return(true);
}
}
catch (Exception)
{
return(false);
}
}
public int Create(Prestacao prestacao)
{
var emailTo = GetEmailTo(prestacao, PrestacaoStatuses.EmAprovacaoOperacional);
_emailService.EnviarEmail(prestacao, PrestacaoStatuses.EmAprovacaoOperacional, emailTo);
return(_repository.Create(prestacao));
}
public void ShouldCallDeletePrestacaoFromPrestaSysDbContext()
{
// Arrange
const int prestacaoToBeDeleted = 7;
const int expectedResult = 1;
var prestacaoEntity = new Prestacao
{
Id = prestacaoToBeDeleted
};
var dbContextMock = new DbContextMock <PrestaSysDbContext>(DummyOptions);
dbContextMock.Setup(s => s.Prestacao.Find(prestacaoToBeDeleted)).Returns(prestacaoEntity);
dbContextMock.Setup(s => s.Prestacao.Remove(prestacaoEntity)).Returns(It.IsAny <EntityEntry <Prestacao> >);
dbContextMock.Setup(s => s.SaveChanges()).Returns(expectedResult);
var prestacaoRepository = new PrestacaoRepository(dbContextMock.Object);
// Act
var result = prestacaoRepository.Delete(prestacaoToBeDeleted);
// Assert
dbContextMock.Verify(m => m.Prestacao.Find(prestacaoToBeDeleted), Times.Once());
dbContextMock.Verify(m => m.Prestacao.Remove(prestacaoEntity), Times.Once());
dbContextMock.Verify(m => m.SaveChanges(), Times.Once());
result.Should().Be(expectedResult);
}
public async Task Test3_ConsultarPrestacoeContratoExcluido()
{
//Arrange
var _options = new DbContextOptionsBuilder <Contratos.Data.DataContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking)
.Options;
// Insert seed data into the database using one instance of the context
using (var context = new Contratos.Data.DataContext(_options))
{
Contrato contrato = new Contrato();
contrato.DataContratacao = DateTime.Now.AddDays(-60);
contrato.ValorFianciado = 12000;
contrato.QuantidadeParcelas = 3;
context.Contratos.Add(contrato);
Prestacao p1 = new Prestacao();
p1.ContratoId = 1;
p1.DataVencimento = DateTime.Now.AddDays(-29);
p1.Valor = 1000;
context.Prestacoes_Contrato.Add(p1);
Prestacao p2 = new Prestacao();
p2.ContratoId = 1;
p2.DataVencimento = DateTime.Now.AddDays(-1);
p2.Valor = 1000;
context.Prestacoes_Contrato.Add(p2);
Prestacao p3 = new Prestacao();
p3.ContratoId = 1;
p3.DataVencimento = DateTime.Now.AddDays(+29);
p3.Valor = 1000;
context.Prestacoes_Contrato.Add(p3);
context.SaveChanges();
context.Entry <Contrato>(contrato).State = EntityState.Detached;
context.Entry <Prestacao>(p1).State = EntityState.Detached;
context.Entry <Prestacao>(p2).State = EntityState.Detached;
context.Entry <Prestacao>(p3).State = EntityState.Detached;
//Act
ActionResult <List <Prestacao> > result = await prestacaoController.GetByContratoId(context, 1);
ActionResult <Contrato> result1 = await contratoController.Delete(context, 1);
ActionResult <List <Prestacao> > result2 = await prestacaoController.GetByContratoId(context, 1);
//Assert
// antes da exclusao existem prestacoes
Assert.IsType <List <Prestacao> >(result.Value);
Assert.NotEmpty(result.Value);
//apos exclusao nao existem mais
Assert.IsType <List <Prestacao> >(result2.Value);
Assert.Empty(result2.Value);
}
}
public string DefineStatus(Prestacao prestacao)
{
var status = "Baixada";
if (prestacao.DataVencimento >= DateTime.Today.Date && prestacao.DataPagamento.Equals(null))
{
status = "Aberta";
}
else if (prestacao.DataVencimento < DateTime.Today.Date && prestacao.DataPagamento.Equals(null))
{
status = "Atrasada";
}
return(status);
}
private List <Prestacao> CriaListaPrestacoes()
{
var prestacao = new Prestacao();
prestacao.ContratoId = 1;
prestacao.DataPagamento = DateTime.Today.Date;
prestacao.DataVencimento = DateTime.Today.Date;
prestacao.Status = "Baixada";
prestacao.Valor = 22;
var prestacoes = new List <Prestacao>();
prestacoes.Add(prestacao);
return(prestacoes);
}
public void Cadastrar(Contrato contrato)
{
contrato.Prestacoes = new List <Prestacao>();
for (int i = 0; i < contrato.QuantidadeParcelas; i++)
{
Prestacao prestacao = new Prestacao
{
DataVencimento = contrato.Data.AddMonths(i + 1),
//IdContrato = (int)contrato.Id,
Valor = (contrato.ValorFinanciado / contrato.QuantidadeParcelas)
};
prestacao.GetStatus();
contrato.Prestacoes.Add(prestacao);
}
RepositorioContrato.Create(contrato);
}
public void RejeitarPrestacaoShouldThrowNotSupportedException()
{
// Arrange
var prestacaoRepository = Mock.Of <IPrestacaoRepository>();
var usuarioService = Mock.Of <IUsuarioService>();
var prestacao = new Prestacao {
Id = 1, Titulo = "Teste"
};
const string justificativa = "Teste de Justificativa";
var rejeitadaActions =
new FinalizadaActions(prestacaoRepository, usuarioService);
// Act & Assert
Assert.ThrowsException <NotSupportedException>(
() => rejeitadaActions.RejeitarPrestacao(prestacao, justificativa));
}
internal PrestacaoViewModel MapeiaEntidadeParaViewModel(Prestacao prestacaoEntidade)
{
if (prestacaoEntidade == null)
{
return(new PrestacaoViewModel());
}
PrestacaoViewModel prestacao = new PrestacaoViewModel()
{
Id = (int)prestacaoEntidade.Id,
DataPagamento = prestacaoEntidade.DataPagamento,
DataVencimento = prestacaoEntidade.DataVencimento,
Status = prestacaoEntidade.Status,
Valor = prestacaoEntidade.Valor
};
return(prestacao);
}
public void PrestacaoPropertiesShouldBeSetAndRetrievedCorrectly()
{
var prestacao = new Prestacao
{
Aprovador = Aprovador,
AprovadorFinanceiro = AprovadorFinanceiro,
AprovadorFinanceiroId = AprovadorFinanceiroId,
AprovadorId = AprovadorId,
Data = _data,
Emitente = Emitente,
EmitenteId = EmitenteId,
Id = Id,
ImagemComprovante = ImagemComprovante,
Justificativa = Justificativa,
JustificativaAprovacao = JustificativaAprovacao,
JustificativaAprovacaoFinanceira = JustificativaAprovacaoFinanceira,
Status = Status,
StatusId = StatusId,
Tipo = Tipo,
TipoId = TipoId,
Titulo = Titulo,
Valor = Valor
};
Assert.AreEqual(prestacao.Aprovador, Aprovador);
Assert.AreEqual(prestacao.AprovadorFinanceiro, AprovadorFinanceiro);
Assert.AreEqual(prestacao.AprovadorFinanceiroId, AprovadorFinanceiroId);
Assert.AreEqual(prestacao.AprovadorId, AprovadorId);
Assert.AreEqual(prestacao.Data, _data);
Assert.AreEqual(prestacao.Emitente, Emitente);
Assert.AreEqual(prestacao.EmitenteId, EmitenteId);
Assert.AreEqual(prestacao.Id, Id);
Assert.AreEqual(prestacao.ImagemComprovante, ImagemComprovante);
Assert.AreEqual(prestacao.Justificativa, Justificativa);
Assert.AreEqual(prestacao.JustificativaAprovacao, JustificativaAprovacao);
Assert.AreEqual(prestacao.JustificativaAprovacaoFinanceira, JustificativaAprovacaoFinanceira);
Assert.AreEqual(prestacao.Status, Status);
Assert.AreEqual(prestacao.StatusId, StatusId);
Assert.AreEqual(prestacao.Id, Id);
Assert.AreEqual(prestacao.Tipo, Tipo);
Assert.AreEqual(prestacao.TipoId, TipoId);
Assert.AreEqual(prestacao.Titulo, Titulo);
Assert.AreEqual(prestacao.Valor, Valor);
}
public void PrestacaoGetByIdShouldBeCalledCorrectly()
{
// Arrange
var prestacao = new Prestacao();
const int id = 7;
var prestacaoRepository = Mock.Of <IPrestacaoRepository>(m => m.GetById(id) == prestacao);
var prestacaoService =
new PrestacaoService(prestacaoRepository, Mock.Of <IEmailService>(), Mock.Of <IPrestacaoStatusActionsFactory>());
// Act
var result = prestacaoService.GetById(id);
// Assert
result.IsSameOrEqualTo(prestacao);
}
public int Update(Prestacao prestacao)
{
if (prestacao == null)
{
throw new ArgumentNullException(nameof(prestacao));
}
try
{
_context.Update(prestacao);
}
catch (InvalidOperationException)
{
var originalEntity = _context.Find(prestacao.GetType(), prestacao.Id);
_context.Entry(originalEntity).CurrentValues.SetValues(prestacao);
_context.Update(originalEntity);
}
return(_context.SaveChanges());
}
public void ShouldCallCreatePrestacaoFromPrestaSysDbContext()
{
// Arrange
const int expectedResult = 1;
var prestacaoEntity = new Prestacao();
var dbContextMock = new DbContextMock <PrestaSysDbContext>(DummyOptions);
dbContextMock.Setup(s => s.Add(prestacaoEntity)).Returns(It.IsAny <EntityEntry <Prestacao> >());
dbContextMock.Setup(s => s.SaveChanges()).Returns(expectedResult);
var prestacaoRepository = new PrestacaoRepository(dbContextMock.Object);
// Act
var result = prestacaoRepository.Create(prestacaoEntity);
// Assert
dbContextMock.Verify(m => m.Add(prestacaoEntity), Times.Once());
dbContextMock.Verify(m => m.SaveChanges(), Times.Once());
result.Should().Be(expectedResult);
}
public void PrestacaoIRejeitarPrestacaoShouldBeCalledCorrectlyWhenInAprovacaoFinanceira()
{
// Arrange
const string titulo = "Titulo";
const string email = "*****@*****.**";
const int id = 1;
const PrestacaoStatuses tipoAprovacao = PrestacaoStatuses.EmAprovacaoFinanceira;
const string justificativa = "Teste Justificativa";
var prestacao = new Prestacao
{
Id = id,
Titulo = titulo,
EmitenteId = 1,
AprovadorId = 2,
AprovadorFinanceiroId = 3,
StatusId = (int)PrestacaoStatuses.EmAprovacaoFinanceira
};
var prestacaoRepository = Mock.Of <IPrestacaoRepository>(m => m.GetById(id) == prestacao);
var factory = Mock.Of <IPrestacaoStatusActionsFactory>(m => m.CreateObject(tipoAprovacao).GetEmailTo(prestacao) == email);
Mock.Get(factory).Setup(m => m.CreateObject(tipoAprovacao).RejeitarPrestacao(prestacao, justificativa))
.Callback(() => prestacao.StatusId = (int)PrestacaoStatuses.Rejeitada);
var emailHelper = Mock.Of <IEmailService>(m => m.EnviarEmail(prestacao, (PrestacaoStatuses)prestacao.StatusId, email));
var prestacaoService =
new PrestacaoService(prestacaoRepository, emailHelper, factory);
// Act
prestacaoService.RejeitarPrestacao(prestacao.Id, justificativa, tipoAprovacao);
// Assert
Mock.Get(prestacaoRepository).Verify(m => m.Update(prestacao), Times.Once);
Mock.Get(factory).Verify(m => m.CreateObject(tipoAprovacao).GetEmailTo(prestacao), Times.Once);
Mock.Get(emailHelper).Verify(m => m.EnviarEmail(prestacao, (PrestacaoStatuses)prestacao.StatusId, email), Times.Once);
prestacao.StatusId.Should().Be((int)PrestacaoStatuses.Rejeitada);
}
// Realiza o cadastro de prestações de um contrato
private List <Prestacao> PostPrestacao(Contrato contrato, int id)
{
List <Prestacao> prestacoes = new List <Prestacao>();
var dataVencimento = DateTime.Today.Date.AddDays(30);
var dataPagamento = DateTime.Today.Date.AddDays(25);
for (var i = 0; i < contrato.QuantidadeParcelas; i++)
{
Prestacao prestacao = new Prestacao();
prestacao.ContratoId = id;
DefineDatas(i, dataPagamento, dataVencimento, prestacao);
prestacao.Valor = (double)contrato.ValorFinanciado / contrato.QuantidadeParcelas;;
prestacao.Status = DefineStatus(prestacao);
_context.Prestacoes.Add(prestacao);
dataVencimento = dataVencimento.AddDays(30);
dataPagamento = dataPagamento.AddDays(25);
prestacoes.Add(prestacao);
}
return(prestacoes);
}
public void RejeitarPrestacaoShouldBeCalledCorrectly()
{
// Arrange
var prestacaoRepository = Mock.Of <IPrestacaoRepository>();
var usuarioService = Mock.Of <IUsuarioService>();
var prestacao = new Prestacao {
Id = 1, Titulo = "Teste"
};
const string justificativa = "Teste de Justificativa";
var aprovacaoFinanceiraActions =
new AprovacaoFinanceiraActions(prestacaoRepository, usuarioService);
// Act
aprovacaoFinanceiraActions.RejeitarPrestacao(prestacao, justificativa);
// Assert
prestacao.StatusId.Should().Be((int)PrestacaoStatuses.Rejeitada);
prestacao.JustificativaAprovacaoFinanceira.Should().Be(justificativa);
}
public void PrestacaoCreateShouldBeCalledCorrectly()
{
// Arrange
const int prestacaoToBeGet = 7;
var prestacao = new Prestacao {
Titulo = "Cristian"
};
var prestacaoRepository = Mock.Of <IPrestacaoRepository>(m => m.Create(prestacao) == prestacaoToBeGet);
var factory = Mock.Of <IPrestacaoStatusActionsFactory>(m => m.CreateObject(It.IsAny <PrestacaoStatuses>()).GetEmailTo(prestacao) == string.Empty);
var prestacaoService =
new PrestacaoService(prestacaoRepository, Mock.Of <IEmailService>(), factory);
// Act
var result = prestacaoService.Create(prestacao);
// Assert
result.IsSameOrEqualTo(prestacaoToBeGet);
}
protected void BtnSalvar_Click(object sender, EventArgs e)
{
try
{
if (TxtDataPagamento.Text.Trim().Equals(String.Empty))
{
TxtDataPagamento.Text = "";
TxtDataPagamento.Focus();
throw new CampoNaoInformadoException("Prestação", "Data de Pagamento", true);
}
else
{
Prestacao lPrestacao = PrestacaoBLL.Instance.BuscarPorId(Convert.ToInt32(Request.QueryString["id"]));
if (lPrestacao.DataPagamento != null)
{
Web.ExibeAlerta(Page, "Prestação´já foi paga!");
}
else if (DateTime.Parse(TxtDataPagamento.Text).Date < lPrestacao.Contrato.DataConcessao)
{
Web.ExibeAlerta(Page, "A data de pagamento não pode ser anterior a data de concessão");
}
else
{
lPrestacao.DataPagamento = DateTime.Parse(TxtDataPagamento.Text);
PrestacaoBLL.Instance.Persistir(lPrestacao);
Web.ExibeAlerta(Page, "Parcela Paga!", "Prestacoes.aspx?id=" + lPrestacao.Contrato.Id);
if (!(ContratoBLL.Instance.ExistePrestacaoAberta(lPrestacao.Contrato)))
{
ContratoBLL.Instance.LiquidarContrato(lPrestacao.Contrato);
Web.ExibeAlerta(Page, "Todas as parcelas foram pagas! Contrato Liquidado", "Prestacoes.aspx");
}
}
}
}
catch (BusinessException ex)
{
Web.ExibeAlerta(Page, ex.Message);
}
}
protected void Page_Load(object sender, EventArgs e)
{
if (!IsPostBack)
{
if (Request.QueryString["id"] == null)
{
Page.Response.Redirect("ContratosAtivos.aspx");
}
else
{
try
{
Prestacao lPrestacao = PrestacaoBLL.Instance.BuscarPorId(Convert.ToInt32(Request.QueryString["id"]));
if (lPrestacao.DataPagamento != null)
{
Web.ExibeAlerta(Page, "Esta prestação já foi paga!", "Prestacoes.aspx?id=" + lPrestacao.Contrato.Id);
}
else if (lPrestacao.Contrato == null)
{
Web.ExibeAlerta(Page, "Operação não pode ser realizada!", "ContratosAtivos.aspx");
}
else
{
PrestacaoBLL.Instance.CorrigirPrestacao(lPrestacao);
lblDataVencimento.Text = lPrestacao.DataVencimento.ToString();
lblValorParcela.Text = lPrestacao.ValorPrincipal.ToString();
lblValorCorrecao.Text = lPrestacao.ValorCorrecao.ToString();
lblTotalPagar.Text = lPrestacao.ValorPrestacao.ToString();
lblDataConcessao.Text = lPrestacao.Contrato.DataConcessao.ToString(@"dd/MM/yyyy");
}
}
catch (BusinessException ex)
{
Web.ExibeAlerta(Page, ex.Message);
}
}
}
}
public void GetEmailToShouldReturnAprovadorFinanceiroId()
{
// Arrange
var prestacaoRepository = Mock.Of <IPrestacaoRepository>();
var usuarioService = Mock.Of <IUsuarioService>();
var prestacao = new Prestacao {
Id = 1, Titulo = "Teste", AprovadorFinanceiroId = 2
};
var expectedUsuario = "*****@*****.**";
Mock.Get(usuarioService).Setup(x => x.GetUsuarioEmailById(prestacao.AprovadorFinanceiroId)).Returns(expectedUsuario);
var rejeitadaActions =
new AprovacaoFinanceiraActions(prestacaoRepository, usuarioService);
// Act
var returnedUsuario = rejeitadaActions.GetEmailTo(prestacao);
// Assert
returnedUsuario.Should().Be(expectedUsuario);
}
public void GetEmailToShouldReturnEmitentId()
{
// Arrange
var prestacaoRepository = Mock.Of <IPrestacaoRepository>();
var usuarioService = Mock.Of <IUsuarioService>();
var prestacao = new Prestacao {
Id = 1, Titulo = "Teste", EmitenteId = 2
};
var expectedUsuario = "*****@*****.**";
Mock.Get(usuarioService).Setup(x => x.GetUsuarioEmailById(prestacao.EmitenteId)).Returns(expectedUsuario);
var finalizadaActions =
new FinalizadaActions(prestacaoRepository, usuarioService);
// Act
var returnedUsuario = finalizadaActions.GetEmailTo(prestacao);
// Assert
returnedUsuario.Should().Be(expectedUsuario);
}
public void PrestacaoIUpdatePrestacaoShouldBeCalledCorrectly()
{
// Arrange
const string titulo = "dasdsad";
var prestacao = new Prestacao {
Titulo = titulo
};
const int id = 7;
var prestacaoRepository = Mock.Of <IPrestacaoRepository>(m => m.Update(prestacao) == id);
var factory = Mock.Of <IPrestacaoStatusActionsFactory>(m => m.CreateObject(It.IsAny <PrestacaoStatuses>()).GetEmailTo(prestacao) == string.Empty);
var prestacaoService =
new PrestacaoService(prestacaoRepository, Mock.Of <IEmailService>(), factory);
// Act
prestacaoService.Update(prestacao);
// Assert
Mock.Get(prestacaoRepository).Verify(m => m.Update(prestacao), Times.Once);
}
public string GetEmailTo(Prestacao prestacao)
{
return(_usuarioService.GetUsuarioEmailById(prestacao.EmitenteId));
}
public void RejeitarPrestacao(Prestacao prestacao, string justificativa)
{
throw new NotSupportedException();
}
public int Create(Prestacao prestacao)
{
_context.Add(prestacao);
return(_context.SaveChanges());
}
public string GetEmailTo(Prestacao prestacao)
{
return(_usuarioService.GetUsuarioEmailById(prestacao.AprovadorFinanceiroId));
}
public void RejeitarPrestacao(Prestacao prestacao, string justificativa)
{
prestacao.StatusId = (int)PrestacaoStatuses.Rejeitada;
prestacao.JustificativaAprovacaoFinanceira = justificativa;
}
