private void BtnAdicionar_Click(object sender, EventArgs e)
{
Locacao add = new Locacao();
add.Livro = (int)cboxLivro.SelectedValue;
add.Usuario = (int)cboxUsuario.SelectedValue;
add.Tipo = (int)cboxGenero.SelectedValue;
add.Devolucao = dateTimePicker1.Value;
add.UsuAlt = Session.usu.Id;
add.UsuInc = Session.usu.Id;
locacaoTableAdapter1.Insert(
add.Livro,
add.Usuario,
add.Tipo,
add.Devolucao,
add.Ativo,
add.UsuInc,
add.UsuAlt,
add.DatInc,
add.DatAlt
);
this.Close();
}
public Locacao BuscarLocacao(int codigoLocacao)
{
Locacao objLocacao = null;
SqlConnection conn = new SqlConnection(connectionString);
conn.Open();
string sql = "SELECT CdLocacao, DtPrevista, ValorTotal, ValorRecebido, DsStatusPg, DsRecebido FROM Locacao WHERE CdLocacao = @codigo";
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddWithValue("@codigo", codigoLocacao);
SqlDataReader dr = cmd.ExecuteReader();
if (dr.HasRows && dr.Read())
{
objLocacao = new Locacao();
objLocacao.CdLocacao = Convert.ToInt32(dr["CdLocacao"]);
objLocacao.DtPrevista = Convert.ToDateTime(dr["DtPrevista"]);
objLocacao.ValorTotal = Convert.ToDecimal(dr["ValorTotal"]);
objLocacao.DsStatusPg = Convert.ToChar(dr["DsStatusPg"]);
objLocacao.DsRecebido = Convert.ToBoolean(dr["DsRecebido"]);
objLocacao.ValorRecebido = Convert.ToDecimal(dr["ValorRecebido"]);
}
conn.Close();
return(objLocacao);
}
public async Task <Locacao> Cadastrar(Locacao entity)
{
await _context.Locacacoes.AddAsync(entity);
_context.SaveChanges();
return(entity);
}
public async Task <Locacao> Alterar(Locacao entity)
{
_context.Locacacoes.Update(entity);
await _context.SaveChangesAsync();
return(entity);
}
private void Button2_Click(object sender, EventArgs e)
{
try
{
if (!verificaCampos())
{
MessageBox.Show("Preencha todos os campos!");
}
else
{
if (MessageBox.Show("Deseja alterar o dado de locação de ID:" + dataGridView1.CurrentRow.Cells[0].Value.ToString() + " ??"
, "Alterar Locação", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
{
Locacao objl = new Locacao
{
locacao_id = (int)dataGridView1.CurrentRow.Cells[0].Value,
locacao_tipo = txt_tipo.Text,
locacao_valor = double.Parse(txt_valor.Text),
locacao_dt_inicio = Convert.ToDateTime(txt_inicio.Text),
locacao_dt_fim = Convert.ToDateTime(txt_fim.Text),
automovel = (int)cb_carro.SelectedValue,
cliente = (int)cb_carro.SelectedValue,
funcionario = (int)cb_funcionario.SelectedValue
};
LocacaoDAO ldao = new LocacaoDAO();
ldao.altera(objl);
Uc_locacao_Load(null, null);
}
}
}
catch (Exception)
{
MessageBox.Show("Erro ao alterar o funcionario");
}
}
private void Button1_Click(object sender, EventArgs e)
{
if (verificaCampos())
{
try
{
Locacao objl = new Locacao
{
locacao_tipo = txt_tipo.Text,
locacao_valor = double.Parse(txt_valor.Text),
locacao_dt_inicio = Convert.ToDateTime(txt_inicio.Text),
locacao_dt_fim = Convert.ToDateTime(txt_fim.Text),
automovel = (int)cb_carro.SelectedValue,
cliente = (int)cb_carro.SelectedValue,
funcionario = (int)cb_funcionario.SelectedValue
};
LocacaoDAO ldao = new LocacaoDAO();
ldao.cadastra_locacao(objl);
Uc_locacao_Load(null, null);
}
catch (Exception t)
{
MessageBox.Show("Erro: " + t);
}
}
else
{
MessageBox.Show("Preencha todos os campos.");
}
}
private void Button3_Click(object sender, EventArgs e)
{
try
{
if (MessageBox.Show("Deseja excluir a locação de ID:" + dataGridView1.CurrentRow.Cells[0].Value.ToString() + " ??"
, "EXCLUSÃO", MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
{
Locacao objl = new Locacao
{
locacao_id = (int)dataGridView1.CurrentRow.Cells[0].Value
};
LocacaoDAO ldao = new LocacaoDAO();
ldao.exclui(objl);
Uc_locacao_Load(null, null);
}
else
{
MessageBox.Show("Exclusão cancelada !");
}
}
catch (Exception)
{
MessageBox.Show("Erro.");
}
}
public void Delete(Locacao entity)
{
// _locacaoRepository.Delete(entity);
entity.Ativo = false;
Update(entity);
}
private void button1_Click(object sender, EventArgs e)
{
Locacao locacao = new Locacao();
locacao.Cliente = this.cliente;
locacao.Filmes = listFilmesSelecionados.ToList();
locacao.FoiPago = chkFoiPago.Checked;
locacao.Funcionario = User.FuncionarioLogado;
LocacaoBLL bll = new LocacaoBLL();
Response response = bll.EfetuarLocacao(locacao);
if (response.Sucesso)
{
MessageBox.Show("Locação efetuada com sucesso!");
this.dataGridView1.DataSource = null;
chkFoiPago.Checked = false;
txtClienteID.Clear();
txtClienteNome.Clear();
txtClienteCPF.Clear();
}
else
{
MessageBox.Show(response.GetErrorMessage());
}
}
public Response EfetuarLocacao(Locacao locacao)
{
string connectionString = SqlData.ConnectionString;
//I/O -> Input/Output
//Arquivos
//Conexões com banco
//Network (comunicação com qualquer hardware externo)
using (SqlConnection connection = new SqlConnection())
{
connection.ConnectionString = SqlData.ConnectionString;
SqlCommand command = new SqlCommand();
command.Connection = connection;
command.CommandText = @"INSERT INTO LOCACOES VALUES
(@CLIENTE,@FUNCIONARIO,
@PRECO,@DATALOCACAO,
@DATAPREVISTADEVOLUCAO,
@DATADEVOLUCAO,@MULTA,
@FOIPAGO);
SELECT SCOPE_IDENTITY()";
command.Parameters.AddWithValue("@CLIENTE", locacao.Cliente.ID);
command.Parameters.AddWithValue("@FUNCIONARIO", locacao.Funcionario.ID);
command.Parameters.AddWithValue("@PRECO", locacao.Preco);
command.Parameters.AddWithValue("@DATALOCACAO", locacao.DataLocacao);
command.Parameters.AddWithValue("@DATAPREVISTADEVOLUCAO", locacao.DataPrevistaDevolucao);
command.Parameters.AddWithValue("@DATADEVOLUCAO", DBNull.Value);
command.Parameters.AddWithValue("@MULTA", locacao.Multa);
command.Parameters.AddWithValue("@FOIPAGO", locacao.FoiPago);
try
{
connection.Open();
int idGerado = Convert.ToInt32(command.ExecuteScalar());
locacao.ID = idGerado;
Response response = new Response();
response.Sucesso = true;
return(response);
}
catch (Exception ex)
{
Response response = new Response();
response.Sucesso = false;
if (ex.Message.Contains("FK_LOCACOES_CLIENTES"))
{
response.Erros.Add("Cliente inexistente.");
}
else if (ex.Message.Contains("FK_LOCACOES_FUNCIONARIOS"))
{
response.Erros.Add("Funcionario inexistente.");
}
else
{
response.Erros.Add("Erro no banco de dados, contate o adm.");
File.WriteAllText("log.txt", ex.Message + " - " + ex.StackTrace);
}
return(response);
}
}//connection.Dispose(); //Conexão fechada automaticamente
}
public async Task <IActionResult> Edit(int id, [Bind("DataEmprestimo,DataDevolucao,Itens,ClienteForeignKey,Id,CreateDate,UpdateDate")] Locacao locacao)
{
if (id != locacao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(locacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LocacaoExists(locacao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ClienteForeignKey"] = new SelectList(_context.Cliente, "Id", "Id", locacao.ClienteForeignKey);
return(View(locacao));
}
public void LocarJogo(int idJogo, int idCliente)
{
var jogo = this.jogoRepositrio.BuscarPorId(idJogo);
var cliente = this.clienteRepositorio.BuscarPorId(idCliente);
if (jogo == null)
{
throw new ArgumentNullException("Jogo da locação não pode ser nulo");
}
if (cliente == null)
{
throw new ArgumentNullException("Cliente da locação não pode ser nulo");
}
var locacao = new Locacao()
{
IdJogo = jogo.Id,
IdCliente = cliente.Id,
Valor = this.GetValorLocacao(jogo),
DataLocacao = DateTime.Now,
DataParaDevolucao = DateTime.Now.AddDays(this.GetDiasDevolucao(jogo)),
Status = StatusLocacao.PENDENTE
};
jogo.AlterarDisponibilidade(false);
this.jogoRepositrio.Atualizar(jogo);
this.locacaoRepositorio.Criar(locacao);
}
public async Task <IHttpActionResult> PutLocacao(int id, Locacao locacao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != locacao.Id)
{
return(BadRequest());
}
db.Entry(locacao).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LocacaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public bool InsertOrUpdateLocacao(Locacao locacao)
{
using (var contexto = new LocadoraContext())
{
try
{
locacao.DataCriacao = DateTime.Now;
//SE O ID É 0 QUER DIZER QUE É ADD CASOU CONTRARIO É UPDATE
if (locacao.Id == 0)
{
contexto.Locacoes.Add(locacao);
}
else
{
contexto.Locacoes.Update(locacao);
}
contexto.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="locacaoObject"></param>
public string EfetuarLocacao(Locacao locacaoObject)
{
WebRequestInfo = (HttpWebRequest)WebRequest.Create(m_requestUrl + "locacao");
WebRequestInfo.ContentType = "application/json";
WebRequestInfo.Method = "POST";
using (var streamWriter = new StreamWriter(WebRequestInfo.GetRequestStream()))
{
string json = "{ ";
// locação
json += "\"dataLocacao\":" + "\"" + DateTime.Now.ToString("yyyy/MM/dd") + "\"" + ",";
// devolução
json += "\"dataDevolucao\":" + "\"" + locacaoObject.Vencimento.ToString("yyyy/MM/dd") + "\"" + ",";
// valor
json += "\"valor\":" + locacaoObject.Valor + ",";
// cliente
json += "\"idCliente\":" + locacaoObject.LocacaoCliente.Id + ",";
// item
json += "\"idItem\":" + locacaoObject.LocacaoItem.Id + " }";
streamWriter.Write(json);
streamWriter.Flush();
streamWriter.Close();
}
return(Response());
}
public bool Devolver(int id)
{
Locacao locacao = contexto.Locacoes.Where(x => x.Id == id).FirstOrDefault();
if (locacao == null)
{
return(false);
}
DateTime now = DateTime.Now.Date;
bool atraso = now > locacao.DataDevolucaoPrevista.Date;
locacao.DataDevolucaoEfetiva = now;
if (!atraso)
{
locacao.PrecoFinalEfetivo = locacao.PrecoFinalPrevisto;
}
else
{
locacao.PrecoFinalEfetivo = CalcularPreco(locacao, now);
}
contexto.Entry(locacao).State = EntityState.Modified;
contexto.SaveChanges();
return(true);
}
public async Task <IActionResult> PutLocacao([FromRoute] int id, [FromBody] Locacao locacao)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != locacao.Id)
{
return(BadRequest());
}
_context.Entry(locacao).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LocacaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok(locacao));
}
public double CalcularPreco(Locacao locacao, DateTime devolucao)
{
int diasLocados = (devolucao.Date - locacao.DataLocacao.Date).Days;
Produto prod = contexto.Produtos.Where(x => x.Id == locacao.IdProduto).FirstOrDefault();
Pacote pac = null;
if (locacao.IdPacote != 0)
{
pac = contexto.Pacotes.Where(x => x.Id == locacao.IdPacote).FirstOrDefault();
}
var precoDiariaPacote = pac == null ? 0 : pac.PrecoDiaria;
var precoOpcionais = 0.0;
List <Opcional> opsDoBanco = new List <Opcional>();
if (locacao.Opcionais != null)
{
foreach (var opcional in locacao.Opcionais)
{
opsDoBanco.Add(contexto.Opcionais.AsNoTracking().Where(x => x.Id == opcional.Id).FirstOrDefault());
}
if (opsDoBanco.Count > 0)
{
precoOpcionais = opsDoBanco.Sum(x => x.Preco);
}
}
return((prod.PrecoDiaria + precoDiariaPacote + precoOpcionais) * diasLocados);
}
public ActionResult Alterar(int Id)
{
var locacao = new List <Locacao>();
var filme = new List <Filme>();
//Seleciona dados da locação - tabela dbo.Locacao
locacao = persistencia.ConsultarLocacao(Id);
//Seleciona os filmes pertencentes a locação - tabela dbo.Filme e tabela dbo.LocacaoFilmes
filme = persistencia.ConsultarFilmeLocado(Id);
//Adiciona os filmes na ViewBag
ViewBag.Filmes = filme;
if (locacao == null)
{
return(HttpNotFound());
}
Locacao loc = new Locacao();
foreach (var item in locacao)
{
loc.Id = item.Id;
loc.CPF = item.CPF;
loc.DtaLocacao = item.DtaLocacao;
}
return(View(loc));
}
public async Task <ActionResult> DeletarLocacao([FromBody] Locacao locacao)
{
try
{
if (locacao == null)
{
return(BadRequest("Nenhum dado informado"));
}
locacao.Excluido = true;
locacao.DataExcluido = DateTime.Now;
_context.Entry(locacao).State = EntityState.Modified;
await _context.SaveChangesAsync();
Filme filme = await _context.Filme.Where(x => x.FilmeId == locacao.FilmeId).FirstOrDefaultAsync();
filme.Alugado = false;
// Desvincula o filme da locação deletada
_context.Entry(filme).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok("Excluido com sucesso"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
private Locacao locacaoSelecionada()
{
LocacaoCrud crud = new LocacaoCrud();
Locacao locacao = crud.ObterLocacao(Convert.ToInt32(locacaoDataGridView.CurrentRow.Cells[0].Value.ToString()));
return(locacao);
}
public ActionResult Alterar(Locacao locacao, int[] FilmeId)
{
if (ModelState.IsValid)
{
//Salva as alterações na tabela dbo.Locacao
contexto.Entry(locacao).State = EntityState.Modified;
contexto.SaveChanges();
//Exclui os registros da tabela dbo.LocacaoFilmes
persistencia.ExcluirLocacaoFilmes(locacao.Id);
//Insere somente os filmes checkados na tabela dbo.LocacaoFilmes
if (FilmeId != null)
{
foreach (int filmeId in FilmeId)
{
persistencia.InserirLocacaoFilmes(locacao.Id, filmeId);
}
}
return(RedirectToAction("Index"));
}
return(View(locacao));
}
public async Task <IActionResult> Edit(int id, [Bind("Id,DataLocacao,DataEntrega")] Locacao locacao)
{
if (id != locacao.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(locacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!LocacaoExists(locacao.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(locacao));
}
public IActionResult Gravar(LocacaoViewModel viewModel)
{
ActionResult action = ValidarLogin(HttpContext);
if (action != null)
{
return(action);
}
var repo = new Repo();
var tipoProduto = repo.SelecionarProdutoTipoPorId(repo.SelecionarProdutoPorId(viewModel.IdProduto).IdProdutoTipo);
var dtLimiteDevolucao = !string.IsNullOrEmpty(viewModel.DtLimiteDevolucao) ? Convert.ToDateTime(viewModel.DtLimiteDevolucao) : DateTime.Now.AddDays(tipoProduto.Prazo);
Locacao locacao = new Locacao()
{
IdUsuario = Sessao.GetIdUsuario(HttpContext),
IdProduto = viewModel.IdProduto,
IdCliente = viewModel.IdCliente,
IdLocacao = viewModel.IdLocacao,
DtDevolucao = string.IsNullOrEmpty(viewModel.DtDevolucao) ? null : (DateTime?)(Convert.ToDateTime(viewModel.DtDevolucao)),
DtLimiteDevolucao = dtLimiteDevolucao,
DtLocacao = DateTime.Now
};
var retorno = repo.GravarLocacao(locacao);
if (retorno == string.Empty)
{
return(RedirectToAction("Index"));
}
else
{
return(Json(new { Result = false, Message = retorno }));
}
}
public static DateTime CalculaData(Locacao locacao)
{
DateTime data = DateTime.Today;
Cliente cliente = Cliente.GetCliente(locacao.ClienteId);
return(data.AddDays(cliente.Dias));
}
public IHttpActionResult PutLocacao(int id, Locacao locacao)
{
if (!ModelState.IsValid)
{
if (ModelState.Keys.First().ToString() != "locacao.Id")
{
return(BadRequest(ModelState));
}
}
if (id != locacao.Id)
{
return(BadRequest());
}
db.Entry(locacao).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!LocacaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public override void Main()
{
var cultura = new CultureInfo("pt-BR");
var cliente = new Cliente("Zezinho da Silva");
using (var streamReader = File.OpenText("filmes.csv"))
{
streamReader.ReadLine();
string linha = string.Empty;
while ((linha = streamReader.ReadLine()) != null)
{
string[] campos = linha.Split('|');
Locacao locacao =
new Locacao(campos[0],
int.Parse(campos[1]),
int.Parse(campos[2]),
int.Parse(campos[3]),
double.Parse(campos[4], NumberStyles.Currency, cultura));
cliente.Adicionar(locacao);
}
}
WriteLine(new Resumo(cliente).GetResumo());
WriteLine();
WriteLine(new ResumoHTML(cliente).GetResumo());
WriteLine();
}
public Locacao Criar(int idCliente, int idVeiculo, int idPacote,
DateTime dataEntregaPrevista, List <int> idLocacaoOpcional)
{
Pacote pacote = null;
var cliente = contexto.Clientes.FirstOrDefault(c => c.Id == idCliente);
var veiculo = contexto.Veiculos.FirstOrDefault(v => v.Id == idVeiculo);
if (idPacote > 0)
{
pacote = contexto.Pacotes.FirstOrDefault(p => p.Id == idPacote);
}
var locacao = new Locacao(veiculo, cliente, pacote, dataEntregaPrevista);
if (idLocacaoOpcional != null)
{
foreach (var id in idLocacaoOpcional)
{
var opcional = contexto.Opcionais.FirstOrDefault(o => o.Id == id);
locacao.LocacaoOpcionais.Add(new LocacaoOpcional(locacao, opcional));
}
}
locacao.calcularValorInicialLocacao();
locacao.atualizarEstoqueItens();
return(locacao);
}
public void TesteTabelaLocacao()
{
Cliente cliente = new Cliente()
{
ClienteId = 15,
Nome = "Gerson",
CPF = "33300068800"
};
Filme filme = new Filme()
{
FilmeId = 15,
Nome = "A Culpa é das Estrelas",
CodigoEan = "98745632156"
};
Locacao locacao = new Locacao()
{
LocacaoId = 1,
Cliente = cliente,
ClienteId = cliente.ClienteId,
Filme = filme,
FilmeId = filme.FilmeId,
DataLocacao = DateTime.Now,
DataDevolucao = DateTime.Now.AddDays(2)
};
using (var dbContext = ServiceProvider.GetService <LocacaoDbContext>())
{
var quantidadeAntesDeInserir = dbContext.Locacacoes.Count();
dbContext.Locacacoes.Add(locacao);
dbContext.SaveChanges();
Assert.IsTrue(dbContext.Locacacoes.Count() > quantidadeAntesDeInserir);
}
}
public IHttpActionResult CadastrarLocacao(LocacaoModel model)
{
var novaLocacao = new Locacao(model.Cliente, model.Pacote, model.Produto, model.DataEntrega, model.Adicional);
repositorio.NovaLocacao(novaLocacao);
return(Ok(new { mensagem = "Cadastrado com Sucesso" }));
}
public IList <Locacao> ListaLocacoes()
{
IList <Locacao> lista = new List <Locacao>();
var sql = "Select * From Locacao";
var resultado = banco.Query(sql);
if (resultado.Count() > 0)
{
Locacao objLocacao;
foreach (var item in resultado)
{
objLocacao = new Locacao
{
CodLocacao = item.codLocacao,
DataInicio = item.dataInicio,
DataEntrega = item.dataEntrega,
TotalCusto = Convert.ToDouble(item.totalCusto),
ObjCliente = new ClienteDAO().Buscar((int)item.clienteID),
ObjVeiculo = new VeiculoDAO().Buscar((int)item.veiculoID)
};
lista.Add(objLocacao);
}
banco.Close();
}
else
{
banco.Close();
return(null);
}
return(lista);
}
public void LocacaoEhFinalizada()
{
var locacao = new Locacao(1, 1);
locacao.RealizarEntrega();
Assert.AreEqual(DateTime.Now, locacao.DataEntrega);
}
public void CriadaLocacaoComClienteEJogo()
{
var cliente = new Cliente(1);
var jogo = new Jogo();
var locacao = new Locacao(jogo, cliente);
Assert.AreEqual(jogo, locacao.Jogo);
Assert.AreEqual(cliente, locacao.Cliente);
}
public bool DevolverJogo(int idJogo)
{
locacao = locacaoRepositorio.BuscarIdPorJogo(idJogo);
if (locacao != null)
{
locacaoRepositorio.Devolver(locacao);
return true;
}
return false;
}
public void CadastrarLocacao(Veiculo veiculo, Cliente cliente)
{
var veicLocado = ctx.Veiculos.Find(veiculo.VeiculoId);
var clienteLocatario = ctx.Clientes.Find(cliente.ClienteId);
var loc = ctx.Locacoes;
Locacao l = new Locacao();
l.Cliente = clienteLocatario;
l.Veiculo = veicLocado;
l.DataSaida = DateTime.Now;
ctx.SaveChanges();
}
private IList<Locacao> Db()
{
var locacoes = new List<Locacao>();
Locacao locacao1 = new Locacao(1)
{
IdCliente = 1,
IdJogo = 1,
Situacao = Situacao.Pendente,
DataLocacao = new DateTime(2015, 11, 11),
DataPrevistaDevolucao = new DateTime(2015, 11, 13),
Jogo = new JogoRepositorioMock().BuscarPorId(1),
Cliente = new ClienteRepositorioMock().BuscarPorId(1),
};
locacoes.Add(locacao1);
return locacoes;
}
public bool LocarJogo(int idCliente, int idJogo)
{
var jogoEncontrado = jogoRepositorio.BuscarPorId(idJogo);
var clienteEncontrado = clienteRepositorio.BuscarPorId(idCliente);
this.locacao = new Locacao(jogoEncontrado, clienteEncontrado);
if (clienteEncontrado != null)
{
var contDeClienteComJogos = locacaoRepositorio.NumeroDeJogosPorCliente(clienteEncontrado);
if (contDeClienteComJogos < 3)
{
locacaoRepositorio.Locar(locacao);
return true;
}
}
return false;
}
public decimal CalcularValorFinal(Locacao locacao)
{
decimal precoBase = locacao.Jogo.Selo.Preco;
int prazo = locacao.Jogo.Selo.PrazoDevolucao;
TimeSpan diff = DateTime.Now - locacao.DataLocacao;
int diasDesdeALocacao = diff.Days;
bool deveAplicarMulta = diasDesdeALocacao > prazo;
if (deveAplicarMulta)
{
decimal valorDaMultaPorDiaAtrasado = 5m;
int diasDeAtraso = diasDesdeALocacao - prazo;
precoBase += diasDeAtraso * valorDaMultaPorDiaAtrasado;
}
return precoBase;
}
private decimal GetValorFinal(Locacao locacao)
{
var diasAtraso = locacao.DataDevolucao.Value.Day - locacao.DataParaDevolucao.Day;
decimal juros = diasAtraso * JUROS;
if (diasAtraso > 0)
{
return locacao.Valor + juros;
}
return locacao.Valor;
}
public int Criar(Locacao locacao)
{
return Db().Any(l => l.Id == locacao.Id) ? 0 : 1;
}
public void LocacaoCriadaComADataAtual()
{
var locacao = new Locacao(1, 1);
Assert.AreEqual(DateTime.Now.Date, locacao.DataLocacao.Date);
}
public bool LocarJogoParaCliente(int idJogo, string nomeCliente)
{
Cliente cliente = clienteRepositorio.BuscarPorNome(nomeCliente).FirstOrDefault(c => c.Nome == nomeCliente);
Jogo jogo = jogoRepositorio.BuscarPorId(idJogo);
bool jogoEClienteSaoValidos = jogo != null && cliente != null;
if (jogoEClienteSaoValidos)
{
if (jogo.Disponivel && ClientePossuiMenosDeTresJogosLocados(cliente))
{
jogo.Disponivel = false;
jogoRepositorio.Atualizar(jogo);
DateTime dataPrevistaParaDevolucao = DateTime.Now.AddDays(jogo.Selo.PrazoDevolucao);
Locacao locacao = new Locacao()
{
IdJogo = jogo.Id,
IdCliente = cliente.Id,
Situacao = Situacao.Pendente,
DataLocacao = DateTime.Now,
DataPrevistaDevolucao = dataPrevistaParaDevolucao
};
locacaoRepositorio.Criar(locacao);
return true;
}
}
return false;
}
public int Atualizar(Locacao locacao)
{
return Db().Any(l => l.Id == locacao.Id) ? 1 : 0;
}