public async Task <IActionResult> PutMovimentacao(int id, Movimentacao movimentacao)
{
if (id != movimentacao.Id)
{
return(BadRequest());
}
_context.Entry(movimentacao).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovimentacaoExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public static IEnumerable <string> ValidarParaSair(MovimentacaoSaidaRequest request, IQueryable <Movimentacao> movimentacoes)
{
DateTime _dataSaida = DateTime.MinValue;
if (request.Id == 0)
{
yield return(Mensagem.ParametroObrigatorio.Formatar(Termo.Movimentacao));
}
if (string.IsNullOrWhiteSpace(request.SaiuEm))
{
yield return(Mensagem.ParametroObrigatorio.Formatar(Termo.SaiuEm));
}
else if (!DateTime.TryParse(request.SaiuEm, out _dataSaida))
{
yield return(Mensagem.ParametroInvalido.Formatar(Termo.SaiuEm));
}
Movimentacao model = movimentacoes.FirstOrDefault(movimentacao => movimentacao.Id == request.Id);
if (DateTime.Compare(model.EntrouEm, _dataSaida) > 0)
{
yield return(Mensagem.DataEntradaMenorQueDataSaida);
}
if (model == null)
{
yield return(Mensagem.EntidadeNaoEncontrada.Formatar(Termo.Veiculo));
}
}
public static IEnumerable <string> ValidarParaExcluir(Movimentacao entidade)
{
if (entidade == null)
{
yield return(Mensagem.EntidadeNaoEncontrada.Formatar(Termo.Movimentacao));
}
}
public void Adicionar(Movimentacao entity)
{
try
{
IDbCommand cmd = conexao.CreateCommand();
cmd.CommandText = "INSERT INTO Movimentacao (ContaId, DataMovimentacao, TipoOperacao, Valor, ValorAtual) VALUES (@ContaId, @DataMovimentacao, @TipoOperacao, @Valor, @ValorAtual); SELECT SCOPE_IDENTITY();";
IDbDataParameter paramContaId = new SqlParameter("ContaId", entity.ContaId);
IDbDataParameter paramDataMovimentacao = new SqlParameter("DataMovimentacao", entity.DataMovimentacao);
IDbDataParameter paramTipoOperacao = new SqlParameter("TipoOperacao", entity.TipoOperacao);
IDbDataParameter paramValor = new SqlParameter("Valor", entity.Valor);
IDbDataParameter paramValorAutal = new SqlParameter("ValorAtual", entity.ValorAtual);
cmd.Parameters.Add(paramContaId);
cmd.Parameters.Add(paramDataMovimentacao);
cmd.Parameters.Add(paramTipoOperacao);
cmd.Parameters.Add(paramValor);
cmd.Parameters.Add(paramValorAutal);
entity.IdMovimentacao = Convert.ToInt32(cmd.ExecuteScalar());
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conexao.Close();
}
}
private void operacaoButton_Click(object sender, EventArgs e)
{
ContaCorrente conta = (ContaCorrente)contaComboBox.SelectedItem;
if (conta is ContaEspecial)
{
conta = (ContaEspecial)contaComboBox.SelectedItem;
}
String historico = "Saque";
Double valor = Double.Parse(valorTextBox.Text);
switch (operacaoComboBox.SelectedIndex)
{
case 0:
conta.EfetuarSaque(valor);
break;
case 1:
conta.EfetuarDeposito(valor);
historico = "Depósito";
break;
default:
throw new Exception("Selecione uma Operação");
}
Movimentacao mov = new Movimentacao(conta, DateTime.Now, historico, valor);
conta.Movimentos.Enqueue(mov);
}
public IActionResult Post([FromBody] Movimentacao item)
{
_context.Movimentacao.Add(item);
_context.SaveChanges();
return(CreatedAtRoute("GetMovimentacao", new { id = item.Id }, item));
}
public bool Resgatar(MovimentacaoRequestDTO dto)
{
ValidarResgate(dto);
var movimentacao = new Movimentacao(dto, TipoMovimentacao.Resgate);
return(_movimentacaoRepository.CriarMovimentacao(movimentacao));
}
public List <Movimentacao> GetAll()
{
string query = "SELECT * FROM Movimentacao";
List <Movimentacao> list = new List <Movimentacao>();
try
{
SqlDataReader reader = db.CallExecuteReader(query);
while (reader.Read())
{
Movimentacao m = new Movimentacao();
m.CodMovimentacao = int.Parse(reader["CodMovimentacao"].ToString());
m.CodUsuario = int.Parse(reader["CodUsuario"].ToString());
m.CodEquipamento = int.Parse(reader["CodEquipamento"].ToString());
m.CodEstoque = int.Parse(reader["CodEstoque"].ToString());;
m.TipoMovimentacao = reader["Estado"].ToString();
m.DataMovimentacao = DateTime.Parse(reader["DataMovimentacao"].ToString());
list.Add(m);
}
reader.Close();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
return(list);
}
public async Task <ActionResult <Movimentacao> > PostMovimentacao(Movimentacao movimentacao)
{
_context.Movimentacoes.Add(movimentacao);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetMovimentacao), new { id = movimentacao.Id }, movimentacao));
}
public void Debitar(Movimentacao entity)
{
var contaCorrente = _contaCorrenteRepository.ObterPorId(entity.ContaId);
entity.DataMovimentacao = DateTime.Now;
entity.TipoOperacao = Enumerators.TipoOperacaoEnum.Debito;
//Debitar
entity.ValorAtual = contaCorrente.ValorAtual - entity.Valor;
if (entity.Valor <= 0)
{
entity.MensagemValidacao.Add("Informe um Valor Positivo para Debitar.");
return;
}
if (contaCorrente.ValorAtual < entity.Valor)
{
entity.MensagemValidacao.Add($"Não há saldo suficiente para Debitar. Saldo Atual: {contaCorrente.ValorAtual} ");
return;
}
// adicionar movimentacao
_movimentacaoRepository.Adicionar(entity);
// Atualizar saldo conta corrente
if (entity.IdMovimentacao > 0)
{
contaCorrente.ValorAtual = entity.ValorAtual;
_contaCorrenteRepository.Atualizar(contaCorrente);
}
}
public async Task <Unit> Handle(UpdateMovimentacaoPrevistaCommand request, CancellationToken cancellationToken)
{
MovimentacaoPrevista movimentacaoPrevista = mapper.Map <MovimentacaoPrevista>(request);
var validate = new MovimentacaoPrevistaValidation().Validate(movimentacaoPrevista);
if (!validate.IsValid)
{
throw new ValidationException(validate.Errors);
}
Movimentacao movimentacao = movimentacaoDomainService.GetByKey(movimentacaoPrevista.IdItemMovimentacao,
movimentacaoPrevista.DataReferencia);
if (movimentacao.MovimentacoesRealizadas.Count == 0 && movimentacaoPrevista.Status.Equals(StatusMovimentacaoPrevista.Q) ||
movimentacao.MovimentacoesRealizadas.Count > 0 && !movimentacaoPrevista.Status.Equals(StatusMovimentacaoPrevista.Q))
{
throw new StatusMovimentacaoInvalidoException(movimentacao.ItemMovimentacao.Descricao,
movimentacao.DataReferencia,
StatusMovimentacaoPrevista.Q);
}
movimentacaoPrevistaDomainService.Update(movimentacaoPrevista);
await mediator.Publish(new MovimentacaoPrevistaNotification
{
MovimentacaoPrevista = movimentacaoPrevista,
Action = ActionNotification.Atualizar
});
return(Unit.Value);
}
private void btnFecharCaixa_Click(object sender, EventArgs e)
{
try
{
movimentacao = new Movimentacao();
movimentacao.Data = DateTime.Today;
movimentacao.Descricao = "Fechamento de caixa";
movimentacao.Valor = faturamentoRepository.SomaFaturamentoTotal(faturamentoRepository.ListarPorPeriodo(dtpInicial.Value, dtpFinal.Value));
movimentacaoRepository.Adicionar(movimentacao);
movimentacaoRepository.Salvar();
caixa = new Caixa();
caixa.Status = "Fechado";
caixa.dataAbertura = dtpInicial.Value;
caixa.dataFechamento = dtpFinal.Value;
foreach (var item in movimentacaoRepository.ListarPorPeriodo(dataInicial, DateTime.Today))
{
caixa.Movimentacoes.Add(item);
}
// Parte responsável por salvar os dados do fechamento de caixa no Banco de dados.
caixaRepository.Adicionar(caixa);
caixaRepository.Salvar();
MessageBox.Show("Fechamento realizado com sucesso!", "Informação", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show("Algo deu errado. Tente novamente ou contate o administrador do sistema. \n\n\nDetalhes: \n" + ex.Message, "ATENÇÃO", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public void IniciarCenario()
{
_conta = new Mock <Conta>();
_contaMovimentada = new Mock <Conta>();
_movimentacao = ObjectMother.ObterMovimentacaoTransferenciaEnviada(_conta.Object, _contaMovimentada.Object);
_contaMovimentada.Setup(cm => cm.Numero).Returns("12345");
}
protected override void Seed(ContextoBancoTabajara contexto)
{
///////////////////////CLIENTES///////////////////////
Cliente cliente = ObjectMother.ObterClienteValido();
contexto.Clientes.Add(cliente);
contexto.SaveChanges();
///////////////////////CONTAS///////////////////////
Conta conta = ObjectMother.ObterContaComCliente(cliente);
contexto.Contas.Add(conta);
contexto.SaveChanges();
///////////////////////MOVIMENTACAO///////////////////////
Movimentacao movimentacao = ObjectMother.ObterMovimentacaoValida(conta);
contexto.Movimentacoes.Add(movimentacao);
contexto.SaveChanges();
conta.Movimentacoes.Add(movimentacao);
///////////////////////INDEXANDO E SALVANDO ALTERACOES///////////////////////
contexto.SaveChanges();
base.Seed(contexto);
}
public Movimentacao Adicionar(Movimentacao movimentacao)
{
_contextoBancoTabajara.Movimentacoes.Add(movimentacao);
_contextoBancoTabajara.SaveChanges();
return(movimentacao);
}
public void Cadastrar(object obj)
{
using (SqlConnection objConn = new SqlConnection(ConfigurationManager.ConnectionStrings["DBGesDoc"].ConnectionString))
{
try
{
objConn.Open();
Movimentacao m = (Movimentacao)obj;
SqlCommand cmd = new SqlCommand("INSERT INTO tbMovimentacoes(idDocumento,setorOrigem,setorDestino,dataHoraMovimentacao,movimentadoPor,recebido,dataHoraRecebimento,prazo,despacho,entreguePara,alertaPrazo) VALUES(@IdDocumento,@SetorOrigem,@SetorDestino,@DataHoraMovimentacao,@MovimentadoPor,@Recebido,@DataHoraRecebimento,@Prazo,@Despacho,@EntreguePara,@AlertaPrazo)", objConn);
cmd.Parameters.Add("@IdDocumento", SqlDbType.Int).Value = m.Documento.IdDocumento;
cmd.Parameters.Add("@SetorOrigem", SqlDbType.Int).Value = m.ProcessoOrigem;
cmd.Parameters.Add("@SetorDestino", SqlDbType.Int).Value = m.ProcessoDestino;
cmd.Parameters.Add("@DataHoraMovimentacao", SqlDbType.VarChar, 20).Value = m.DataHoraMovimentacao;
cmd.Parameters.Add("@MovimentadoPor", SqlDbType.VarChar, 100).Value = m.MovimentadoPor;
cmd.Parameters.Add("@Recebido", SqlDbType.VarChar, 3).Value = m.Recebido;
cmd.Parameters.Add("@DataHoraRecebimento", SqlDbType.VarChar, 20).Value = m.DataHoraRecebimento;
cmd.Parameters.Add("@Prazo", SqlDbType.Date).Value = m.Prazo;
cmd.Parameters.Add("@Despacho", SqlDbType.Text).Value = m.Despacho;
cmd.Parameters.Add("@EntreguePara", SqlDbType.VarChar, 100).Value = m.EntreguePara;
cmd.Parameters.Add("@AlertaPrazo", SqlDbType.VarChar, 3).Value = m.AlertaPrazo;
cmd.ExecuteNonQuery();
}
catch (Exception)
{
throw;
}
finally
{
objConn.Close();
}
}
}
void Start()
{
movScript = FindObjectOfType <Movimentacao>();
combosScript = FindObjectOfType <Combos>();
dashScript = FindObjectOfType <dashMove>();
jumpScript = FindObjectOfType <PlayerJump>();
pauseScript = FindObjectOfType <pauseInGame>();
//CHAMAR TRANSIÇÃO
transicaoParaODia = FindObjectOfType <TransicaoParaODia>();
if (SceneManager.GetActiveScene().name == "CenaFinal")
{
GetComponent <Animator>().SetBool("bCenaFinal", true);
if (GetComponent <Animator>().GetInteger("countStand") == 0)
{
StartCoroutine(waitStand());
}
GetComponent <Animator>().SetBool("bStretch", true);
}
else
{
GetComponent <Animator>().SetBool("bArtesFinalizacao", false);
}
fadeScript = FindObjectOfType <Fade>();
}
public virtual void Transferir(Conta contaMovimentada, double valorTransferencia)
{
if (this.Saldo - valorTransferencia < -this.Limite)
{
throw new SaldoInsuficienteExcecao();
}
Movimentacao transferenciaEnviada = new Movimentacao
{
Conta = this,
ContaMovimentada = contaMovimentada,
Data = DateTime.Now,
TipoOperacao = TipoOperacaoMovimentacao.TRANSFERENCIA_ENVIADA,
Valor = valorTransferencia
};
this.Movimentacoes.Add(transferenciaEnviada);
this.Saldo -= valorTransferencia;
Movimentacao transferenciaRecebida = new Movimentacao
{
Conta = contaMovimentada,
ContaMovimentada = this,
Data = DateTime.Now,
TipoOperacao = TipoOperacaoMovimentacao.TRANSFERENCIA_RECEBIDA,
Valor = valorTransferencia
};
contaMovimentada.Movimentacoes.Add(transferenciaRecebida);
contaMovimentada.Saldo += valorTransferencia;
}
public Conta Depositar(string id, double valor)
{
string login = ControllerContext.RequestContext.Principal.Identity.Name;
Cliente cliente = Repository.Cliente.GetByLogin(login);
Conta conta = Repository.Conta.GetById(Convert.ToInt32(id));
conta.Depositar(valor);
Repository.Conta.Save(conta);
Movimentacao movimentacao = new Movimentacao()
{
Conta = conta,
Saldo = conta.Saldo,
TipoMovimento = TipoMovimento.DEPOSITO,
Valor = valor,
Data = DateTime.Now
};
Repository.Movimentacao.Save(movimentacao);
return(conta);
}
private void GridPesq_SelectionChanged(object sender, EventArgs e)
{
if (GridPesq.SelectedRows.Count > 0)
{
movimentacao = (Movimentacao)GridPesq.SelectedRows[0].DataBoundItem;
}
}
public async Task <IActionResult> Edit(int id, [Bind("MovimentacaoID,Quantidade,EstoqueID,ProdutoID")] Movimentacao movimentacao)
{
if (id != movimentacao.MovimentacaoID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try {
_context.Update(movimentacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovimentacaoExists(movimentacao.MovimentacaoID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["EstoqueID"] = new SelectList(_context.Estoques, "Id", "Nome", movimentacao.EstoqueID);
ViewData["ProdutoID"] = new SelectList(_context.Produtos, "Id", "Nome", movimentacao.ProdutoID);
return(View(movimentacao));
}
public Conta Add(JObject request)
{
string login = ControllerContext.RequestContext.Principal.Identity.Name;
Cliente cliente = Repository.Cliente.GetByLogin(login);
ContaFactory contaFactory = new ContaFactory();
Conta conta = contaFactory.Create(cliente, request);
conta = Repository.Conta.Save(conta);
Movimentacao movimentacao = new Movimentacao()
{
Conta = conta,
Saldo = conta.Saldo,
TipoMovimento = TipoMovimento.DEPOSITO,
Valor = request["deposito"].ToObject <double>(),
Data = DateTime.Now
};
Repository.Movimentacao.Save(movimentacao);
return(conta);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,TipoMovimentacao,DataInicio,DataFim")] Movimentacao movimentacao)
{
if (id != movimentacao.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(movimentacao);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!MovimentacaoExists(movimentacao.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(movimentacao));
}
public void Creditar(Movimentacao entity)
{
if (entity.Valor <= 0)
{
entity.MensagemValidacao.Add("Informe um Valor Positivo para Creditar.");
return;
}
entity.TipoOperacao = Enumerators.TipoOperacaoEnum.Debito;
var contaCorrente = _contaCorrenteRepository.ObterPorId(entity.ContaId);
entity.DataMovimentacao = DateTime.Now;
entity.TipoOperacao = Enumerators.TipoOperacaoEnum.Credito;
// Creditar
entity.ValorAtual = contaCorrente.ValorAtual + entity.Valor;
// adicionar movimentacao
_movimentacaoRepository.Adicionar(entity);
// Atualizar saldo conta corrente
if (entity.IdMovimentacao > 0)
{
contaCorrente.ValorAtual = entity.ValorAtual;
_contaCorrenteRepository.Atualizar(contaCorrente);
}
}
void Start()
{
fisica = GetComponent <Rigidbody2D>();
destroiinimigo = GameObject.Find("Gauchito").GetComponent <Movimentacao>();
Time.timeScale = 1;
}
public void Add(List <MovimentacaoPrevista> movimentacoesPrevistas)
{
try
{
unitOfWork.BeginTransaction();
foreach (MovimentacaoPrevista movimentacaoPrevista in movimentacoesPrevistas)
{
Movimentacao movimentacao = unitOfWork.IMovimentacaoRepository.GetByKey(movimentacaoPrevista.IdItemMovimentacao,
movimentacaoPrevista.DataReferencia);
if (movimentacao != null)
{
unitOfWork.IMovimentacaoRepository.Update(movimentacaoPrevista.Movimentacao);
}
unitOfWork.IMovimentacaoPrevistaRepository.Add(movimentacaoPrevista);
}
unitOfWork.Commit();
}
catch (Exception e)
{
unitOfWork.Rollback();
throw new Exception(e.Message);
}
finally
{
unitOfWork.Dispose();
}
}
public int Movimentar(Movimentacao movimentacao)
{
AcessoDadosSqlServer acessoDados = new AcessoDadosSqlServer();
try
{
string instrucaoEstoque = "INSERT INTO Estoque (quantidade, codigoproduto, data, hora, motivo, acao) VALUES (@quantidade, @codigoproduto, @data, @hora, @motivo, @acao); ";
string instrucaoProduto = "";
if (movimentacao.Acao == "Entrada")
{
instrucaoProduto = "UPDATE Produto Set qtdatual = qtdatual + @quantidade WHERE codigo = @codigoproduto";
}
else
{
instrucaoProduto = "UPDATE Produto SET qtdatual = qtdatual - @quantidade WHERE codigo = @codigoproduto";
}
SqlCommand command = new SqlCommand(instrucaoEstoque + instrucaoProduto, acessoDados.Conectar());
command.Parameters.AddWithValue("@quantidade", movimentacao.Quantidade);
command.Parameters.AddWithValue("@codigoproduto", movimentacao.CodigoProduto);
command.Parameters.AddWithValue("@data", movimentacao.Data);
command.Parameters.AddWithValue("@hora", movimentacao.Hora);
command.Parameters.AddWithValue("@motivo", movimentacao.Motivo);
command.Parameters.AddWithValue("@acao", movimentacao.Acao);
return(Convert.ToInt32(command.ExecuteNonQuery()));
}
catch (Exception erro)
{
throw erro;
}
}
public static Movimentacao Depositar(Movimentacao movimentacao, Conta conta)
{
movimentacao.Tipo = "Deposito";
movimentacao.Valor = movimentacao.ValorDeposito;
conta.SaldoAtual = conta.SaldoAtual + movimentacao.ValorDeposito;
return(movimentacao);
}
private void btnSalvar_Click(object sender, EventArgs e)
{
if (!ValidarCampos())
{
return;
}
this.Movimentacao = this.Movimentacao ?? new Movimentacao();
this.Movimentacao.Produto = new Produto()
{
Id = (int)cboProduto.SelectedValue
};
this.Movimentacao.Data = txtData.Value;
this.Movimentacao.Tipo = rdbE.Checked ? "E" : "S";
this.Movimentacao.Quantidade = !string.IsNullOrWhiteSpace(txtQuantidade.Text) ? Convert.ToInt32(txtQuantidade.Text) : 0;
if (this.Movimentacao != null && this.Movimentacao.Id > 0)
{
new MovimentacaoDAO().Atualizar(this.Movimentacao);
}
else
{
new MovimentacaoDAO().Inserir(this.Movimentacao);
}
DialogResult = DialogResult.OK;
}
public MovimentacaoSoftparkViewModel(Movimentacao movimentacao)
{
Id = movimentacao.IdSoftpark.HasValue && movimentacao.IdSoftpark.Value > 0 ? movimentacao.IdSoftpark.Value : movimentacao.Id;
DataInsercao = movimentacao.DataInsercao;
NumFechamento = movimentacao.NumFechamento;
NumTerminal = movimentacao.NumTerminal;
DataAbertura = movimentacao.DataAbertura;
DataFechamento = movimentacao.DataFechamento;
Ticket = movimentacao.Ticket;
Placa = movimentacao.Placa;
DataEntrada = movimentacao.DataEntrada;
DataSaida = movimentacao.DataSaida;
ValorCobrado = movimentacao.ValorCobrado;
DescontoUtilizado = movimentacao.DescontoUtilizado;
ValorDesconto = movimentacao.ValorDesconto;
TipoCliente = movimentacao.TipoCliente;
NumeroContrato = movimentacao.NumeroContrato;
ClienteId = movimentacao.Cliente.Id;
VagaIsenta = movimentacao.VagaIsenta;
Cpf = movimentacao.Cpf;
Rps = movimentacao.Rps;
FormaPagamento = movimentacao.FormaPagamento;
MovimentacaoSelo = movimentacao.MovimentacaoSelo.Select(x => new MovimentacaoSeloSoftparkViewModel(x, this)).ToList();
Estacionamento = movimentacao.Unidade != null ? new EstacionamentoSoftparkViewModel(movimentacao.Unidade) : null;
Operador = movimentacao.Usuario != null ? new OperadorSoftparkViewModel(movimentacao.Usuario) : null;
}
public override string ToString()
{
QdeDeLinhas = 1;
var textoFilhos = RegI010.ToString();
_IND_DAD = Movimentacao.SemDados;
if (RegI010.QdeDeLinhas > 0)
_IND_DAD = Movimentacao.ComDados;
QdeDeLinhas += RegI010.QdeDeLinhas;
return "|I001|" +
IND_DAD.FormataParaSPED().FimDaLinha() +
textoFilhos;
}
