public Movimentacao Movimentar(decimal valor, TipoOperacao operacao)
{
Movimentacao ultimaMovimentacao = Movimentacoes.OrderByDescending(o => o.DataMovimentacao)
.FirstOrDefault();
var movimentacao = new Movimentacao()
{
IdContaCorrente = Id,
ContaCorrente = this,
Operacao = operacao,
Valor = valor,
DataMovimentacao = DateTime.Now,
IdUltimaMovimentacao = ultimaMovimentacao?.Id,
UltimaMovimentacao = ultimaMovimentacao,
UltimoSaldo = ultimaMovimentacao?.UltimoSaldo ?? 0
};
if ((movimentacao.Operacao == TipoOperacao.Debito &&
(movimentacao.UltimoSaldo + (-1 * movimentacao.Valor)) < -2500))
{
throw new RuleException("Você atingiu o limite de crédito", "005");
}
Movimentacoes.Add(movimentacao);
return(movimentacao);
}
private Operacao(Operacao op)
{
tipoOperacao = op.tipoOperacao;
tipoDado = op.tipoDado;
aresta = op.aresta;
vertice = op.vertice;
}
public Agendamento(
int motoristaId,
int veiculoId,
string cte,
int transportadoraId,
int periodoId,
int recintoTRA,
string recintoDEPOT,
TipoOperacao tipoOperacao,
TipoAgendamento tipoAgendamento,
int quantidade,
bool imo,
bool excesso,
int usuarioId)
{
MotoristaId = motoristaId;
VeiculoId = veiculoId;
CTE = cte;
TransportadoraId = transportadoraId;
PeriodoId = periodoId;
RecintoTRA = recintoTRA;
RecintoDEPOT = recintoDEPOT;
TipoOperacao = tipoOperacao;
TipoAgendamento = tipoAgendamento;
Quantidade = quantidade;
IMO = imo;
Excesso = excesso;
UsuarioId = usuarioId;
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Nome")] TipoOperacao tipoOperacao)
{
if (id != tipoOperacao.Id)
{
return(RedirectToAction(nameof(Error), new { message = "Id mismatch" }));
}
if (ModelState.IsValid)
{
try
{
await _tipoOperacaoService.UpdateAsync(tipoOperacao);
}
catch (DbUpdateConcurrencyException e)
{
//if (!TipoOperacaoExists(tipoOperacao.Id))
if (tipoOperacao == null)
{
return(RedirectToAction(nameof(Error), new { message = "Id not found" }));
}
else
{
return(RedirectToAction(nameof(Error), new { message = e.Message }));
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(tipoOperacao));
}
/// <summary>
/// Verifica se já existe um usuário com o email passado por parâmetro
/// </summary>
/// <param name="integrante"></param>
/// <param name="tipoOperacao"></param>
/// <returns></returns>
public static bool VericarEmailExistente(Integrante integrante, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List <Integrante> integrantes = (from c in db.Integrantes
where c.Email.Equals(integrante.Email)
select c).ToList();
if (!string.IsNullOrEmpty(integrante.Email))
{
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (integrantes.Count > 0)
{
return(true);
}
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (integrantes.Count > 0)
{
foreach (Integrante user in integrantes)
{
if (user.Email.Equals(integrante.Email) && user.ID != integrante.ID)
{
return(true);
}
}
}
}
}
return(false);
}
public ActionResult <OperacaoDTO> GetOperacaoByNome(String nome)
{
long id = 0;
List <Operacao> listaOperacoes = _context.Operacoes.ToList();
foreach (Operacao oper in listaOperacoes)
{
if (oper.nome.nome == nome)
{
id = oper.Id;
}
}
Operacao op = Orepo.SelectById(id);
if (op == null)
{
return(NotFound());
}
long idTipoOp = op.tipoOpId;
TipoOperacao t = TOrepo.SelectById(idTipoOp);
OperacaoDTO dto = new OperacaoDTO {
nomeTipoOp = t.nome.nome, nomeOperacao = op.nome.nome, duracao = op.duracao
};
return(dto);
}
/// <summary>
/// Converter a string para o Enum do tipo correspondente.
/// </summary>
/// <param name="pString">String do Tipo</param>
public static TipoOperacao ConverterStringTipoOperacao(string pString)
{
TipoOperacao tipoOperacao = TipoOperacao.Nenhuma;
//
switch (pString)
{
case "Alteracao":
tipoOperacao = TipoOperacao.Alteracao;
break;
case "Cadastro":
tipoOperacao = TipoOperacao.Cadastro;
break;
case "Exclusao":
tipoOperacao = TipoOperacao.Exclusao;
break;
case "AlteracaoSenha":
tipoOperacao = TipoOperacao.AlteracaoSenha;
break;
}
//
return(tipoOperacao);
}
/// <summary>
/// Retorna uma operação sob a interface IOperação para ser consumida pelo nucleo da aplicação.
/// </summary>
/// <param name="TipoOperacao"></param>
/// <param name="Requisitante">Objeto Representando a origem da operação</param>
/// <param name="Alvo">Objeto representando o destino da operação quando aplicável</param>
/// <returns></returns>
public static IOperacao ObterOperacao(TipoOperacao TipoOperacao, Conta Requisitante, Conta Alvo = null)
{
switch (TipoOperacao)
{
case TipoOperacao.Deposito:
return(new Deposito {
Alvo = Alvo, Requisitante = Requisitante
});
case TipoOperacao.Saque:
return(new Saque {
Alvo = Alvo, Requisitante = Requisitante
});
case TipoOperacao.Transferencia:
if (Alvo == null)
{
throw new InvalidOperationException("Não é possível fazer uma transferencia sem destino");
}
return(new Transferencia {
Alvo = Alvo, Requisitante = Requisitante
});
}
return(null);
}
/// <summary>
/// Verifica se já existe um usuário com o email passado por parâmetro
/// </summary>
/// <param name="integrante"></param>
/// <param name="tipoOperacao"></param>
/// <returns></returns>
public static bool VericarEmailExistente(Integrante integrante, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List<Integrante> integrantes = (from c in db.Integrantes
where c.Email.Equals(integrante.Email)
select c).ToList();
if (!string.IsNullOrEmpty(integrante.Email))
{
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (integrantes.Count > 0)
return true;
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (integrantes.Count > 0)
{
foreach (Integrante user in integrantes)
{
if (user.Email.Equals(integrante.Email) && user.ID != integrante.ID)
{
return true;
}
}
}
}
}
return false;
}
private char converteOperacao(TipoOperacao operacao)
{
char retorno;
switch (operacao)
{
case TipoOperacao.Adicao:
retorno = '+';
break;
case TipoOperacao.Subtracao:
retorno = '-';
break;
case TipoOperacao.Multiplicacao:
retorno = '*';
break;
case TipoOperacao.Divisao:
retorno = '/';
break;
default:
retorno = '@';
break;
}
return(retorno);
}
public ResultadoTributacao(ITributavelProduto produto, Crt crtEmpresa, TipoOperacao operacao, TipoPessoa tipoPessoa)
{
_produto = produto;
CrtEmpresa = crtEmpresa;
Operacao = operacao;
TipoPessoa = tipoPessoa;
}
public decimal Operar(decimal numA, decimal numB, TipoOperacao tipo)
{
if (tipo == TipoOperacao.Soma)
{
return(numA + numB);
}
if (tipo == TipoOperacao.Subtracao)
{
return(numA - numB);
}
if (tipo == TipoOperacao.Divisao)
{
if (numB == 0)
{
throw new DivideByZeroException("O denominador não pode ser 0");
}
else
{
return(numA / numB);
}
}
else
{
return(numA * numB);
}
}
public IEnumerable <OperacaoDTO> GetOperacoesByDescricaoTipoMaquina(String descricao)
{
long id = 0;
List <TipoMaquina> listaTipo = _context.TipoMaquinas.ToList();
foreach (TipoMaquina tm in listaTipo)
{
if (tm.descricao.descricao == descricao)
{
id = tm.Id;
}
}
IEnumerable <Operacao> operacaoL = TMORepo.SelectOperacoesByIdTM(id);
List <OperacaoDTO> listaFinal = new List <OperacaoDTO> ();
foreach (Operacao p in operacaoL)
{
long tipoOp = p.tipoOpId;
TipoOperacao to = TORepo.SelectById(tipoOp);
listaFinal.Add(ToDTO.OperacaoToOperacaoDTO(p, to));
}
IEnumerable <OperacaoDTO> l = listaFinal;
return(l);
}
public Agendamento(
int id,
int motoristaId,
int veiculoId,
string cte,
bool cegonha,
int transportadoraId,
int periodoId,
string emailRegistro,
TipoOperacao tipoOperacao,
bool dueDesembaracada,
int usuarioId)
{
Id = id;
MotoristaId = motoristaId;
VeiculoId = veiculoId;
CTE = cte;
Cegonha = cegonha;
TransportadoraId = transportadoraId;
PeriodoId = periodoId;
EmailRegistro = emailRegistro;
TipoOperacao = tipoOperacao;
DueDesembaracada = dueDesembaracada;
UsuarioId = usuarioId;
}
public RegistrarLancamentoCommand(Guid id, decimal valor, TipoOperacao tipoOperacao, long numeroConta)
{
Id = id;
Valor = valor;
TipoOperacao = tipoOperacao;
NumeroConta = numeroConta;
}
/// <summary>
/// Obtem requisição por referencia, tipo de operação e etapa.
/// </summary>
public async Task <Requisicao> ObterTodosPorStatusAsync(int referencia, TipoOperacao tipoOperacao, EtapaRequisicao etapa, StatusOperacao status)
{
var requisicaoObj = _db.Requisicao.Include(a => a.ServicoWsSoap).Where(p => p.Referencia == referencia && p.TipoOperacao == tipoOperacao && p.Etapa == etapa && p.Status == status)
.OrderBy(o => o.DataCadastro).FirstOrDefaultAsync();
return(await requisicaoObj);
}
public EixoX GerarEixoXGrafico(List <OperacaoDTO> pListaOperacao, TipoOperacao pTipoOperacao, Color pCor, string pNome, DateTime pDataIncial, DateTime pDataFinal)
{
var ValoresX = new EixoX()
{
Cor = pCor, Nome = pNome
};
List <Object> listaEixoX = new List <object>();
while (pDataIncial <= pDataFinal)
{
List <double> listaCalculo = new List <double>();
foreach (var item in pListaOperacao)
{
var valor = item.Parcelas.Where(parcela => parcela.DataVencimentoParcela.Month == pDataIncial.Month && item.TipoOperacao == pTipoOperacao).Sum(parcela => parcela.Valor_Parcela);
listaCalculo.Add(valor);
}
listaEixoX.Add(listaCalculo.Sum());
ValoresX.Valores = listaEixoX;
pDataIncial = pDataIncial.AddMonths(1);
}
return(ValoresX);
}
/// <summary>
/// Verifica se já existe um calendário com o ano passado por parâmetro
/// </summary>
/// <param name="calendario"></param>
/// <param name="tipoOperacao"></param>
/// <returns></returns>
public static bool VericarCalendarioExistente(Calendario calendario, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List <Calendario> calendarios = (from c in db.Calendarios
where c.Ano.Equals(calendario.Ano)
select c).ToList();
if (calendario.Ano > 0)
{
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (calendarios.Count > 0)
{
return(true);
}
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (calendarios.Count > 0)
{
foreach (Calendario c in calendarios)
{
if (c.Ano.Equals(calendario.Ano) && c.ID != calendario.ID)
{
return(true);
}
}
}
}
}
return(false);
}
public static string[] Select(Entidade entidade, int id, TipoOperacao tipoOperacao)
{
if (tipoOperacao == TipoOperacao.leituraMuitosRegistros)
{
List <string> list = new List <string>();
string path = GetPathOfEntity(entidade);
using (StreamReader sr = File.OpenText(path))
{
while (!sr.EndOfStream)
{
string line = sr.ReadLine();
string[] dados = line.Split(',');
if (int.Parse(dados[0]) == id)
{
list.Add(line);
}
}
}
GenerateLog(entidade, TipoOperacao.select, "Leitura de varios registros");
return(list.ToArray());
}
GenerateLog(entidade, TipoOperacao.select, "Leitura de varios registros (falhou)");
return(null);
}
public static bool VericarCodigoExistente(Produto produto, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List<Produto> produtos = (from c in db.Produtos
where c.CodigoInterno.Equals(produto.CodigoInterno)
select c).ToList();
if (!string.IsNullOrEmpty(produto.CodigoInterno))
{
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (produtos.Count > 0)
return true;
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (produtos.Count > 0)
{
foreach (Produto prod in produtos)
{
if (prod.CodigoInterno.Equals(produto.CodigoInterno) && prod.ID != produto.ID)
{
return true;
}
}
}
}
}
return false;
}
public Proposta(TipoOperacao tipoOperacao, int situacao, decimal valorParcela, decimal valorTotal = 0)
{
TipoOperacao = tipoOperacao;
Situacao = situacao;
ValorParcela = valorParcela;
ValorTotal = valorTotal;
}
/// <summary>
/// Método que verifica se usuário já existe
/// </summary>
/// <param name="usuario"></param>
/// <param name="tipoOperacao"></param>
/// <returns></returns>
public bool VerificaUsuarioExistente(Usuario usuario, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List <Usuario> usuarios = (from u in db.Usuario
where u.Login.Equals(usuario.Login)
select u).ToList();
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (usuarios.Count > 0)
{
return(true);
}
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (usuarios.Count > 0)
{
foreach (var item in usuarios)
{
if (item.Login.Equals(usuario.Login) && item.ID != usuario.ID)
{
return(true);
}
}
}
}
return(false);
}
public static Operacao EfetuarOperacao(Conta origem, Conta destino, decimal valor
, TipoOperacao tipo)
{
if (tipo == TipoOperacao.Credito)
{
origem.Creditar(valor);
destino.Debitar(valor);
}
if (tipo == TipoOperacao.Debito)
{
origem.Debitar(valor);
destino.Creditar(valor);
}
var operacao = new Operacao
{
ContaOrigem = origem,
ContaDestino = destino,
Tipo = tipo,
DateCriacao = DateTime.Now
};
Lancamento.Registrar(operacao);
return(operacao);
}
public IEnumerable <Modelo> ObterModelosPorTipoOperacao(TipoOperacao tipo)
{
using (OracleConnection con = new OracleConnection(Config.StringConexao()))
{
return(con.Query <Modelo>(@"SELECT Id, Descricao FROM CRM.TB_CRM_MODELO WHERE TipoOperacao = :tipo AND Status = 1 ORDER BY DESCRICAO", new { tipo }));
}
}
public Resumo(decimal valorTotal, TipoOperacao tipoOperacao, string observacao, DateTime primeiroVencimento, bool viavel = false)
{
ValorTotal = valorTotal;
TipoOperacao = tipoOperacao.ToString();
Observacao = observacao;
PrimeiroVencimento = primeiroVencimento;
Viavel = viavel;
}
public Calculo(int id, double numero1, TipoOperacao operacao, double?numero2, double?resultado)
{
Id = id;
Numero1 = numero1;
Operacao = operacao;
Numero2 = numero2;
Resultado = resultado;
}
private void btnExcluir_Click(object sender, EventArgs e)
{
operacao = TipoOperacao.Excluindo;
if (MessageBox.Show(Mensagens.PerguntaExclusao, Mensagens.Titulo, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1) == DialogResult.Yes)
{
Excluir();
}
}
private void DeveTerRegistradoUmaOperacaoDe(TipoOperacao tipoEsperado, Lado lado, Equacao equacao, TermoEquacao termo, int noIndice)
{
var operacoes = equacao.HistoricoOperacoes.ObterOperacoes(lado);
var operacao = operacoes[noIndice];
operacao.Tipo.Should().Be(tipoEsperado);
operacao.Termo.Should().Be(termo);
}
public int AddAndMountOperacao(
TipoOperacao tipo, Acao ativo, int qtd, double preco)
{
Operacao operacao = new Operacao(tipo, ativo);
operacao.Montar(qtd, preco);
return(this.AddOperacao(operacao));
}
public ResultadoTributacao(ITributavelProduto produto, Crt crtEmpresa, TipoOperacao operacao, TipoPessoa tipoPessoa, TipoDesconto tipoDesconto = TipoDesconto.Incondicional)
{
_produto = produto;
CrtEmpresa = crtEmpresa;
Operacao = operacao;
TipoPessoa = tipoPessoa;
TipoDesconto = tipoDesconto;
}
private void AuditarOperacao(double quantia, TipoOperacao tipoOperacao)
{
RegistroBancario registro = new RegistroBancario();
registro.TipoOperacao = tipoOperacao;
registro.QuantiaTransacao = quantia;
registro.SaldoPosOperacao = this.Saldo;
historico.Add(registro);
}
public async Task <IActionResult> Create([Bind("Id,Nome")] TipoOperacao tipoOperacao)
{
if (ModelState.IsValid)
{
await _tipoOperacaoService.InsertAsync(tipoOperacao);
return(RedirectToAction(nameof(Index)));
}
return(View(tipoOperacao));
}
public static OperacaoDTO OperacaoToOperacaoDTO(Operacao operacao, TipoOperacao tipo)
{
OperacaoDTO dto;
dto = new OperacaoDTO {
nomeTipoOp = tipo.nome.nome, nomeOperacao = operacao.nome.nome, duracao = new Duracao(operacao.duracao.minutos, operacao.duracao.segundos)
};
return(dto);
}
public Pedido Salvar(Pedido pedido, TipoOperacao tipoOperacao)
{
if(tipoOperacao.Equals(TipoOperacao.Create))
{
return this.Criar(pedido);
}
else if(tipoOperacao.Equals(TipoOperacao.Update))
{
return this.Atualizar(pedido);
}
return pedido;
}
private void LocalizaConfiguracao()
{
remag_configuracao config = Globals.DataContext.remag_configuracao.FirstOrDefault(c => c.sefip != null || c.remag != null);
if (config != null)
{
this.textBoxRemag.Text = config.remag;
this.textBoxSefip.Text = config.sefip;
operacao = TipoOperacao.Editando;
}
else
{
operacao = TipoOperacao.Adicionando;
}
}
private void btnEditar_Click(object sender, EventArgs e)
{
operacao = TipoOperacao.Editando;
_controle.HabilitaDesabilitaControles(this, TipoOperacao.Editando);
}
public static bool VericarLoginExistente(Usuario usuario, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List<Usuario> usuarios = (from c in db.Usuarios
where c.Login.Equals(usuario.Login)
select c).ToList();
if (!string.IsNullOrEmpty(usuario.Login))
{
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (usuarios.Count > 0)
return true;
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (usuarios.Count > 0)
{
foreach (Usuario user in usuarios)
{
if (user.Login.Equals(usuario.Login) && user.ID != usuario.ID)
{
return true;
}
}
}
}
}
return false;
}
public static bool VericarCodigoExistente(Cliente cliente, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List<Cliente> clientes = (from c in db.Clientes
where c.CodigoInterno.Equals(cliente.CodigoInterno)
select c).ToList();
if (!string.IsNullOrEmpty(cliente.CodigoInterno))
{
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (clientes.Count > 0)
return true;
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (clientes.Count > 0)
{
foreach (Cliente cli in clientes)
{
if (cli.CodigoInterno.Equals(cliente.CodigoInterno) && cli.ID != cliente.ID)
{
return true;
}
}
}
}
}
return false;
}
/// <summary>
/// Método que verifica se usuário já existe
/// </summary>
/// <param name="usuario"></param>
/// <param name="tipoOperacao"></param>
/// <returns></returns>
public bool VerificaUsuarioExistente(Usuario usuario, TipoOperacao tipoOperacao)
{
Contexto db = new Contexto();
List<Usuario> usuarios = (from u in db.Usuario
where u.Login.Equals(usuario.Login)
select u).ToList();
if (tipoOperacao.Equals(TipoOperacao.Create))
{
if (usuarios.Count > 0)
return true;
}
else if (tipoOperacao.Equals(TipoOperacao.Update))
{
if (usuarios.Count > 0)
{
foreach (var item in usuarios)
{
if (item.Login.Equals(usuario.Login) && item.ID != usuario.ID)
return true;
}
}
}
return false;
}
