public Transacao(string descricao, decimal valor, TipoTransacao tipotransacao)
{
Descricao = descricao;
Valor = valor;
TipoTransacao = tipotransacao;
DataHora = DateTime.Now;
}
public Transacoes(TipoTransacao tipoTransacao, string descricao, decimal valor, DateTime dtHora)
{
TipoTransacao = tipoTransacao;
Descricao = descricao;
Valor = valor;
DtHora = dtHora;
}
/// <summary>
/// Realiza a validacao basica do TipoTransacao a ser lancado
/// </summary>
/// <param name="tipoTransacao"></param>
public void ValidarTipoTransacao(TipoTransacao tipoTransacao)
{
if (tipoTransacao == null)
{
throw new ArgumentException(MensagemResposta.TipoTransacaoInvalido);
}
}
public IEnumerable <Transacao> ConsultarExtrato(Conta conta, DateTime dataInicio, DateTime dataFim)
{
var contaResult = this.GetById(conta.IdConta);
if (contaResult != null)
{
if (this.PodeTarifar(contaResult, DateTime.Now, TipoTransacao.EXTRATO()))
{
var tarifa = _transacaoService.CriarTransacao(contaResult, "Tarifa de Consulta de Extrato", "", DateTime.Now, contaResult.Banco.TarifaConsultarExtrato * (-1), null, TipoTransacao.TARIFA());
_transacaoService.Save(tarifa);
contaResult.Tarifar(tarifa.ValorTransacao);
_contaRepository.Update(contaResult);
}
else
{
var operacao = _transacaoService.CriarTransacao(contaResult, "1º Consulta de Extrato", "", DateTime.Now, 0.0, null, TipoTransacao.EXTRATO());
_transacaoService.Save(operacao);
}
_unitOfWork.Commit();
return(this._transacaoService.ConsultarExtrato(conta, dataInicio, dataFim).Where(e => e.ValorTransacao != 0.0));
}
return(null);
}
public Transacoes(double valor, TipoTransacao tipoTransacao, Guid contaId)
{
Valor = valor;
TipoTransacao = tipoTransacao;
ContaId = contaId;
DataCadastro = DateTime.Now;
}
public ActionResult Detalhar(int codEmpresa, int codTransacao, TipoTransacao tipo)
{
Transacao transacao;
string descricaoMaterial = null;
switch (tipo)
{
case TipoTransacao.OrdemServico:
transacao = ProdutoSC.GetOrdemServico(codEmpresa, codTransacao);
descricaoMaterial = GetDescricaoMaterial((OrdemServico) transacao);
break;
case TipoTransacao.Pedido:
transacao = ProdutoSC.GetPedido(codEmpresa, codTransacao);
break;
default:
transacao = ProdutoSC.GetTransacao(codEmpresa, codTransacao);
break;
}
var viewModel = new ComprasDetalhar {
Transacao = transacao,
Material = descricaoMaterial
};
return View(viewModel);
}
public Transacao(Guid Id, TipoTransacao tipoTransacao, int valor, string descricao)
{
this.IdTransacao = Id;
this.TipoTransacao = tipoTransacao;
this.Valor = valor;
this.Descricao = descricao;
}
public double ConsultarSaldo(Conta conta)
{
var contaResult = this.GetById(conta.IdConta);
if (contaResult != null)
{
if (this.PodeTarifar(contaResult, DateTime.Now, TipoTransacao.CONSULTAR_SALDO()))
{
var tarifa = _transacaoService.CriarTransacao(contaResult, "Tarifa de Consulta de Saldo", "", DateTime.Now, contaResult.Banco.TarifaConsultarSaldo * (-1), null, TipoTransacao.TARIFA());
_transacaoService.Save(tarifa);
contaResult.Tarifar(tarifa.ValorTransacao);
_contaRepository.Update(contaResult);
}
else
{
var operacao = _transacaoService.CriarTransacao(contaResult, "1º Consulta de Saldo", "", DateTime.Now, 0.0, null, TipoTransacao.CONSULTAR_SALDO());
_transacaoService.Save(operacao);
}
_unitOfWork.Commit();
return(contaResult.SaldoConta);
}
return(0.0);
}
public OperacaoDataModel(ObjectId id, DateTime?dataHora, decimal valor, TipoTransacao tipo)
{
Id = id;
DataHora = dataHora;
Valor = valor;
Tipo = tipo;
}
public Conta Sacar(Conta conta, double valor)
{
var contaResult = this.GetById(conta.IdConta);
if (contaResult == null)
{
conta.AddNotification(new Notification("IdConta", "Conta não localizada no sistema"));
return(conta);
}
contaResult.Sacar(valor);
if (contaResult.Valid)
{
if (this.PodeTarifar(contaResult, DateTime.Now, TipoTransacao.SAQUE()))
{
var tarifa = _transacaoService.CriarTransacao(contaResult, "Tarifa de Saque", "", DateTime.Now, contaResult.Banco.TarifaSaque * (-1), null, TipoTransacao.TARIFA());
_transacaoService.Save(tarifa);
contaResult.Tarifar(tarifa.ValorTransacao);
}
var operacao = _transacaoService.CriarTransacao(contaResult, "Saque", "", DateTime.Now, valor * (-1), null, TipoTransacao.SAQUE());
_transacaoService.Save(operacao);
_contaRepository.Update(contaResult);
_unitOfWork.Commit();
}
return(contaResult);
}
public Operacao(Guid idTransaction, decimal valor, TipoTransacao operacao, DateTime?dataHora)
{
IdTransaction = idTransaction;
Valor = valor;
Tipo = operacao;
DataHora = dataHora;
}
public Transacao(TipoTransacao tipoTransacao, string descricao, decimal valor)
{
TipoTransacao = tipoTransacao;
Descricao = descricao;
Valor = valor;
DataHora = DateTime.Now;
}
public TransacaoBancaria(DateTime data, TipoTransacao tipo, decimal valor, string descricao)
{
Data = data;
Tipo = tipo;
Valor = valor;
Descricao = descricao;
}
public Transacao(Conta conta, ValorTransacao valor, TipoTransacao tipo, DataVencimento dataLancamento, DataEfetivacao dataEfetivacao)
{
Conta = conta;
Valor = valor;
Tipo = tipo;
DataVencimento = dataLancamento;
DataEfetivacao = dataEfetivacao;
}
public Transacao(TipoTransacao tipo, DateTime data, double valor, CriptomoedaHoje criptomoedaHoje, ContaCliente contaCliente)
{
Tipo = tipo;
Data = data;
Valor = valor;
CriptomoedaHoje = criptomoedaHoje;
ContaCliente = contaCliente;
}
public Transacoes(Conta contaOrigem, TipoTransacao tipoTransacao, decimal valor)
: this()
{
AdicionarData();
AdicionarContaOrigem(contaOrigem);
AdicionarTipoTransacao(tipoTransacao);
AdicionarValor(valor);
}
public Transacao(TipoTransacao tipoTransacaoId, Guid numeroContaOrigem, Guid numeroContaDestino, double valor, StatusTrasferencia statusTrasferenciaId)
{
TipoTransacaoId = tipoTransacaoId;
DtTransacao = DateTime.Now;
NumeroContaOrigem = numeroContaOrigem;
NumeroContaDestino = numeroContaDestino;
Valor = valor;
StatusTrasferenciaId = statusTrasferenciaId;
}
public ActionResult Nova(TipoTransacao tipo)
{
return(this.View("Editar", new EditarTransacaoForm
{
Tipo = tipo,
Contas = new ContaRepository().Todos(),
Categorias = new CategoriaRepository().Hierarquia()
}));
}
private Transacao(TipoTransacao tipoTransacao, Conta contaDestino, decimal valor)
{
TipoTransacao = tipoTransacao;
ContaDestino = contaDestino;
ContaDestinoId = contaDestino.Id;
Valor = valor;
Extornado = false;
DataCriacao = DateTime.Now;
}
public Transacao(IContaCorrente conta, TipoTransacao tipo, DateTime dataHora, decimal saldoAnterior, decimal valor, decimal saldoFinal, string descricao)
{
ContaCorrenteId = conta.Id;
_contaCorrente = conta;
Tipo = tipo;
DataHora = dataHora;
SaldoAnterior = saldoAnterior;
Valor = valor;
SaldoFinal = saldoFinal;
Descricao = descricao;
}
public void Pagar(decimal valor, string conta, TipoTransacao tipoTransacao)
{
if (tipoTransacao == TipoTransacao.Debito)
{
// Realiza transação no cartão por Débito
}
if (tipoTransacao == TipoTransacao.Credito)
{
// Realiza transação no cartão por Crédito
}
}
public Movimento(DateTime dt, TipoTransacao tpTrans, int qtdAprovada, int qtdNegada,
double vlrTrans, double vlrInter, string nmArq, string tpValTrans
)
{
this.Data = dt;
this.Transacao = tpTrans.Tipo;
this.QuantidadeAprovada = qtdAprovada;
this.QuantidadeNegada = qtdNegada;
this.ValorTransacao = vlrTrans;
this.ValorInterchange = vlrInter;
this.Arquivo = nmArq;
this.TipoValorTransacao = tpValTrans;
}
/// <summary>
/// Realiza a validacao basica do Saldo da conta para o lancamento da transacao
/// </summary>
/// <param name="conta"></param>
/// <param name="transacaoParam"></param>
/// <param name="tipoTransacao"></param>
public void ValidarSaldo(Conta conta, TransacaoDTO transacaoParam, TipoTransacao tipoTransacao)
{
decimal valorSaldoAtual = transacaoParam.Valor * tipoTransacao.FlagSaldoAtual;
if (transacaoParam.Valor <= 0)
{
throw new ArgumentException(MensagemResposta.ValorTransacaoInvalido);
}
if (conta.SaldoAtual + valorSaldoAtual < 0)
{
throw new ArgumentException(MensagemResposta.ContaSemSaldoParaOperacao);
}
}
public override void Validacao()
{
if (IdPedido.HasValue && (!ValorPedido.HasValue || ValorPedido.Value == 0))
{
Mensagens.Add("O pedido relacionado à transação não tem um valor válido.");
}
if (ValorTransacao <= 0)
{
Mensagens.Add("O valor a ser transacionado no cashback é inválido");
}
if (Enum.TryParse <TipoTransacaoExtratoEnum>(TipoTransacao.ToString(), out _))
{
Mensagens.Add("O tipo de transação informado é inválido.");
}
}
public void Processar(TipoTransacao tipo, long contaId, long categoriaId, decimal valor, string descricao = "")
{
var conta = this.contaRepository.ById(contaId);
var categoria = this.categoriaRepository.ById(categoriaId);
if (tipo == TipoTransacao.Gasto)
{
this.gastoService.Lancar(conta, categoria, valor, descricao);
}
else if (tipo == TipoTransacao.Recebimento)
{
this.recebimentoService.Lancar(conta, categoria, valor, descricao);
}
// TODO: throw
}
public string excluirTipoTransacao(TipoTransacao t)
{
string erro = null;
try
{
db.TipoTransacao.DeleteObject(t);
db.SaveChanges();
}
catch (Exception ex)
{
erro = ex.Message;
}
return erro;
}
public string excluirTipoTransacao(TipoTransacao t)
{
string erro = null;
try
{
db.TipoTransacao.DeleteObject(t);
db.SaveChanges();
}
catch (Exception ex)
{
erro = ex.Message;
}
return(erro);
}
public Movimento(TipoServico serv, DateTime dt, TipoTransacao trans, int qtd, double vlr, string tpVlr, double vlrInter,
string tpInter, double vlrProsCharge, double vlrSett, string tpVlrSett, string nmArq, DateTime dtArquivo)
{
this.Servico = serv.Tipo;
this.ProcessingDate = dt;
this.Transacao = trans.Tipo;
this.Quantidade = qtd;
this.TransactionAmount = vlr;
this.TipoTransactionAmount = tpVlr;
this.InterchangeFee = vlrInter;
this.TipoInterchangeFee = tpInter;
this.ProcessingCharge = vlrProsCharge;
this.PaymentAmount = vlrSett;
this.TipoPaymentAmount = tpVlrSett;
this.Arquivo = nmArq;
this.DataArquivo = dtArquivo;
}
/// <summary>
/// Realiza os procedimentos necessarios para inclusao de uma nova transacao na conta.
/// </summary>
/// <param name="conta"></param>
/// <param name="transacaoParam"></param>
/// <param name="tipoTransacao"></param>
/// <returns></returns>
public Conta AdicionarTransacao(Conta conta, TransacaoDTO transacaoParam, TipoTransacao tipoTransacao)
{
decimal valorSaldoAtual = transacaoParam.Valor * tipoTransacao.FlagSaldoAtual;
conta.SaldoAtual = conta.SaldoAtual + valorSaldoAtual;
conta.Transacao.Add(new Transacao
{
IdConta = transacaoParam.IdConta,
DataHora = transacaoParam.DataHora,
IdTipoTransacao = transacaoParam.IdTipoTransacao,
Valor = Math.Round(transacaoParam.Valor, 2),
Historico = transacaoParam.Historico,
});
return(conta);
}
public Movimento(TipoServico tpServ, DateTime dt, TipoTransacao tpTrans, string prCode, int qtd, double rcAmt,
string rcTpAmt, string rcCurr, double vlrFee, string tpFee, string feeCur, string svcID,
string nmArq
)
{
this.Servico = tpServ.Tipo;
this.Data = dt;
this.Transacao = tpTrans.Tipo;
this.ProcCode = prCode;
this.Quantidade = qtd;
this.ReconAmount = rcAmt;
this.TipoReconAmount = rcTpAmt;
this.ReconCurrCode = rcCurr;
this.Fee = vlrFee;
this.TipoFee = tpFee;
this.FeeCurrCode = feeCur;
this.ServiceID = svcID;
this.Arquivo = nmArq;
}
public string editarTipoTransacao(TipoTransacao t)
{
string erro = null;
try
{
if (t.EntityState == System.Data.EntityState.Detached)
db.TipoTransacao.Attach(t);
db.ObjectStateManager.ChangeObjectState(t, System.Data.EntityState.Modified);
db.SaveChanges();
}
catch (Exception ex)
{
erro = ex.Message;
}
return erro;
}
public string editarTipoTransacao(TipoTransacao t)
{
string erro = null;
try
{
if (t.EntityState == System.Data.EntityState.Detached)
{
db.TipoTransacao.Attach(t);
}
db.ObjectStateManager.ChangeObjectState(t, System.Data.EntityState.Modified);
db.SaveChanges();
}
catch (Exception ex)
{
erro = ex.Message;
}
return(erro);
}
public Conta Transferir(Conta contaOrigem, Conta contaDestino, double valor)
{
var contaOrigemResult = this.GetById(contaOrigem.IdConta);
if (contaOrigemResult == null)
{
contaOrigem.AddNotification(new Notification("IdConta", "Conta de Origem não localizada no sistema"));
return(contaOrigem);
}
var contaDestinoResult = this.GetById(contaDestino.IdConta);
if (contaDestinoResult == null)
{
contaDestino.AddNotification(new Notification("IdConta", "Conta de Destino não localizada no sistema"));
return(contaDestino);
}
contaOrigemResult.Transferir(contaDestinoResult, valor);
if (contaOrigemResult.Valid)
{
if (this.PodeTarifar(contaOrigemResult, DateTime.Now, TipoTransacao.TRANSFERENCIA()))
{
var tarifa = _transacaoService.CriarTransacao(contaOrigemResult, "Tarifa de Transferência", "", DateTime.Now, contaOrigemResult.Banco.TarifaTransferencia * (-1), contaDestinoResult, TipoTransacao.TARIFA());
_transacaoService.Save(tarifa);
contaOrigemResult.Tarifar(tarifa.ValorTransacao);
}
_transacaoService.Save(_transacaoService.CriarTransacao(contaOrigemResult, "Transferência", "", DateTime.Now, valor * (-1), contaDestinoResult, TipoTransacao.TRANSFERENCIA()));
_transacaoService.Save(_transacaoService.CriarTransacao(contaDestinoResult, "Transferência", "", DateTime.Now, valor, contaOrigemResult, TipoTransacao.TRANSFERENCIA()));
_contaRepository.Update(contaOrigemResult);
_contaRepository.Update(contaDestinoResult);
_unitOfWork.Commit();
}
return(contaOrigemResult);
}
