internal void Criar(Operacao v_oOperacao)
{
try
{
sbSQL.Length = 0;
sbSQL.Append("INSERT INTO TBPRO020(");
sbSQL.Append("DSAPLDOPRC,");
sbSQL.Append("NMOPRC");
sbSQL.Append(") VALUES (");
sbSQL.Append(":DSAPLDOPRC,");
sbSQL.Append(":NMOPRC");
sbSQL.Append(")");
sbSQL = TratarSQLParametroBanco(sbSQL.ToString());
oCmd = ObterCommand(sbSQL.ToString());
UtDbNet.AdicionarParametro(oCmd, TratarSQLParametroBanco("DSAPLDOPRC").ToString(), v_oOperacao.Apelido);
UtDbNet.AdicionarParametro(oCmd, TratarSQLParametroBanco("NMOPRC").ToString(), v_oOperacao.Nome);
oCmd.ExecuteNonQuery();
v_oOperacao.Codigo = ObterNovoCodigo(oCmd, "SEQTBPRO020");
oCmd.Dispose();
}
catch (Exception ex)
{
throw new Dor.Util.OperacaoInvalidaBD(ex);
}
}
public override double Calcular(Operacao operacao, Corretora corretora)
{
double total = operacao.Quantidade*operacao.Cotacao.Valor;
total += 10;
total += total*0.03;
return total;
}
protected bool CheckOperacao(ConexaoBase AConexao, Operacao AMethodo)
{
bool podeExecutarOperacao = AConexao.MetodosCRUD.Contains(AMethodo);
if (!podeExecutarOperacao)
throw new EOperacaoNaoPermitida(AMethodo.ToString(), AConexao.Nome);
return podeExecutarOperacao;
}
private void TB_PREDECESSORAS_RowDeleting(object sender, System.Data.DataRowChangeEventArgs e)
{
TB_PREDECESSORASRow predecessora = (TB_PREDECESSORASRow)e.Row;
Grafo.Aresta a = grafo.FindAresta(predecessora.PRED_CODIGO, predecessora.SUCE_CODIGO);
Operacao op = new Operacao(Operacao.TipoOperacao.Rem, a);
GerenciarOperacao(op);
}
public override double Calcular(Operacao operacao, Corretora corretora)
{
double total = operacao.Quantidade * operacao.Cotacao.Valor;
total += 10;
total += total * 0.03;
return(total);
}
//private model.SistemaHotelContext _context;
//private model.Modelo _modelo;
//private repositorio.ModeloRepositorio _modeloRepositorio;
public FrmModeloFormulario(Operacao op, model.SistemaHotelContext context /*, model.Modelo modelo*/)
{
_op = op;
//_context = context;
//_modelo = modelo;
//_modeloRepositorio = new repositorio.ModeloRepositorio(_context);
InitializeComponent();
Util.acertaTabOrder(this);
}
public static void Executar()
{
Operacao soma = (x, y) => x + y;
Operacao subtracao = (x, y) => x - y;
Operacao multiplicacao = (x, y) => x * y;
Console.WriteLine($"Soma: {soma(10,10)}");
Console.WriteLine($"Subtração: {subtracao(10,5)}");
Console.WriteLine($"Multiplicação: {multiplicacao(10,4)}");
}
public FrmPermissaoFormulario(Operacao op, model.SistemaHotelContext context, model.Permissao permissao)
{
_op = op;
_context = context;
_funcionalidadeEntrada = null;
_permissao = permissao;
_permissaoRepositorio = new repositorio.PermissaoRepositorio(_context);
InitializeComponent();
Util.acertaTabOrder(this);
}
public static void Executar()
{
Operacao sum = (x, y) => x + y;
Operacao sub = (x, y) => x - y;
Operacao mult = (x, y) => x * y;
Console.WriteLine(sum(2, 5));
Console.WriteLine(sub(3, 3));
Console.WriteLine(mult(32131232132, 43242342));
}
public void Remove(Operacao objeto)
{
banco = new BancoContext();
using (banco)
{
banco.Operacoes.Remove(objeto);
banco.SaveChanges();
}
}
public FrmFuncionalidadeFormulario(Operacao op, model.SistemaHotelContext context, model.Funcionalidade funcionalidade)
{
_op = op;
_context = context;
_funcionalidade = funcionalidade;
_funcionalidadeRepositorio = new repositorio.FuncionalidadeRepositorio(_context);
InitializeComponent();
Util.acertaTabOrder(this);
}
public static void Executar()
{
Operacao sum = (x, y) => x + y;
Operacao sub = (x, y) => x - y;
Operacao mult = (x, y) => x * y;
Console.WriteLine(sum(17, 25));
Console.WriteLine(sub(100, 58));
Console.WriteLine(mult(21, 2));
}
public void InsertOperacao()
{
var operacao = new Operacao();
//OperacaoRepository repository = new OperacaoRepository();
operacao.NomeOperacao = "Adicionar";
//repository.Add(operacao);
}
private Operacao CarregarItem(DataRow item)
{
VMDataRow dtRow = new VMDataRow(item);
Operacao operacao = new Operacao();
operacao.IDOperacao = dtRow.GetInt("IDOperacao");
operacao.Descricao = dtRow.GetStr("Descricao");
return(operacao);
}
public Registro(double valor, string descrição, DateTime data, Tipo tipo, Operacao operacao, Department department, Fonte fonte)
{
Valor = valor;
Descrição = descrição;
Data = data;
Tipo = tipo;
Operacao = operacao;
Department = department;
Fonte = fonte;
}
public static void Executar()
{
Operacao sum = (x, y) => x + y;
Operacao sub = (x, y) => x - y;
Operacao mult = (x, y) => x * y;
System.Console.WriteLine(sum(3, 3));
System.Console.WriteLine(sub(5, 2));
System.Console.WriteLine(mult(12, 8));
}
public static void Executar()
{
Console.WriteLine(Calculadora(Soma, 15, 5));
Operacao operacaoSubtracao = (int x, int y) => x - y;
Console.WriteLine(Calculadora(operacaoSubtracao, 25, 15));
Console.ReadKey();
}
public static void Executar()
{
Operacao soma = (x, y) => x + y;
Operacao subtracao = (x, y) => x - y;
Operacao multiplicacao = (x, y) => x * y;
Console.WriteLine(soma(5, 9));
Console.WriteLine(subtracao(36, 26));
Console.WriteLine(multicacao(7, 9));
}
public Log(Operacao operacao)
{
IUsuario usuario = new Usuario();
usuario.RecuperarUsuarioLogado();
usuario.ValidarId();
this.Usuario = usuario;
this.Operacao = operacao;
this.DataHora = DateTime.Now;
}
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 FrmReservaAreaComumDevolucao(Operacao op, model.SistemaHotelContext context, model.Usuario usuarioLogado, model.Reserva_area_comum reserva_area_comum)
{
_op = op;
_context = context;
_usuarioLogado = usuarioLogado;
_reserva_area_comum = reserva_area_comum;
_reserva_area_comumRepositorio = new repositorio.Reserva_area_comumRepositorio(_context);
InitializeComponent();
Util.acertaTabOrder(this);
}
public static void Executar()
{
Operacao sum = (x, y) => x + y;
Operacao sub = (x, y) => x - y;
Operacao mult = (x, y) => x * y;
Console.WriteLine(sum(3, 3));
Console.WriteLine(sub(3, 3));
Console.WriteLine(mult(3, 3));
}
public static void Executar()
{
Operacao sum = (x, y) => x + y;
Operacao subtracao = (x, y) => x - y;
Operacao multiplicacao = (x, y) => x * y;
Console.WriteLine(sum(3, 3));
Console.WriteLine(subtracao(5, 2));
Console.WriteLine(multiplicacao(12, 8));
}
public static void Executar()
{
Operacao Sum = (x, y) => x + y;
Operacao Sub = (x, y) => x - y;
Operacao Mult = (x, y) => x * y;
Console.WriteLine(Sum(3, 3));
Console.WriteLine(Sub(5, 2));
Console.WriteLine(Mult(12, 8));
}
public void Test1(int b, int a, int resultadoteste)
{
int resultado;
Operacao operacaoTeste = new Operacao();
resultado = operacaoTeste.Multiplicacao(b, a);
Assert.Equal(resultado, resultadoteste);
}
public FrmProcedimentoCorpo(Operacao op, model.SistemaHotelContext context, model.Procedimento procedimento)
{
_op = op;
_context = context;
_procedimento = procedimento;
_procedimento_passoRepositorio = new repositorio.Procedimento_passoRepositorio(_context);
_procedimento_passo_produtoRepositorio = new repositorio.Procedimento_passo_produtoRepositorio(_context);
InitializeComponent();
Util.acertaTabOrder(this);
}
protected override Task Handle(AddOperacaoCommand command, CancellationToken cancellationToken)
{
var tipoOperacao = OperacaoTipo.Parse(command.TipoOperacao);
var operacao = new Operacao(command.Id, command.Data, tipoOperacao, command.Ativo, command.Quantidade, command.Preco, command.Conta);
_operacaoRepository.Add(operacao);
return(Task.FromResult(0));
}
delegate double Operacao(double x, double y); //delegate tipo tipo(chamando o tipo, no exemplo, Operacao)
public static void Executar()
{
Operacao sum = (x, y) => x + y; //sum é uma variável do tipo delegate.
Operacao sub = (x, y) => x - y;
Operacao mult = (x, y) => x * y;
Console.WriteLine(sum(3, 3));
Console.WriteLine(sub(5, 2));
Console.WriteLine(mult(12, 8));
}
public static void Executar()
{
Operacao Somar = (x, y) => x + y;
Operacao Sub = (x, y) => x - y;
Operacao Mult = (x, y) => x * y;
Console.WriteLine(Somar(2, 2));
Console.WriteLine(Sub(10, 6));
Console.WriteLine(Mult(10, 10));
}
public void RealizaTransferencia(ViewContaBancaria viewConta, RelatorioOperacaoDao relatorioDao, ContaBancariaDao contaDao)
{
Console.Clear();
Console.WriteLine("Informe o ID da sua conta bancaria");
int IdContaOrigem = Convert.ToInt32(Console.ReadLine());
ContaBancaria contaOrigem = contaDao.BuscaPorId(IdContaOrigem);
if (contaOrigem != null)
{
Operacao operacao = new Operacao();
Console.WriteLine("\nConfirme os dados: \n");
viewConta.ListaEFormata();
Console.WriteLine("\nInforme o ID da conta bancaria que vai receber a transferencia");
int IdContaDestino = Convert.ToInt32(Console.ReadLine());
ContaBancaria contaMovimentada = contaDao.BuscaPorId(IdContaDestino);
if (contaMovimentada != null)
{
Console.WriteLine("\nConfirme os dados: \n");
viewConta.ListaEFormata();
Console.WriteLine("\nInforme o valor a ser transferido: ");
double ValorTransferencia = Convert.ToDouble(Console.ReadLine());
if (contaOrigem.Saldo < ValorTransferencia)
{
Console.WriteLine("Voce não tem saldo suficiente para fazer este depósito");
}
else
{
contaOrigem.Saque(ValorTransferencia);
contaMovimentada.Deposito(ValorTransferencia);
operacao.RealizaOperacao(contaMovimentada, contaOrigem, 3, ValorTransferencia);
relatorioDao.AdicionaNovaOperacao(operacao);
Console.WriteLine("Operacao realizada com sucesso");
}
}
else
{
Console.WriteLine("Nenhuma conta encontrada");
}
}
else
{
Console.WriteLine("Nenhuma conta encontrada");
}
}
public Boolean DebitarValor(Conta conta, double valor, Operacao op)
{
string saldoCaixa = (ObterSaldoCaixa()[0] + valor).ToString().Replace(".", "").Replace(",", ".");
Conta atual = obterConta(conta);
string valorOp = (atual.ValorDisponivel - valor).ToString().Replace(".", "").Replace(",", ".");
string valorSaque = (atual.LimiteDiario - valor).ToString().Replace(".", "").Replace(",", ".");
SqlCommand cmd = new SqlCommand();
SqlTransaction transaction;
cmd.CommandType = CommandType.Text;
cmd.Connection = con.conectar();
transaction = con.beginTransaction();
cmd.Transaction = transaction;
try
{
string updateSaldoCaixa = "UPDATE CAIXA SET SALDO_CAIXA = " + saldoCaixa;
string sqlUpdate = "UPDATE CONTA SET SALDO = " + valorOp + ", LIMITE_SAQUE = " + valorSaque + " WHERE COD_CONTA = " + conta.NumeroConta;
string sqlInsert = "INSERT INTO EXTRATO(TIPO_MOVIMENTACAO, DATA_MOVIMENTACAO, VALOR, CONTA_ORIGEM, CONTA_DESTINO) " +
"VALUES ('" + (char)op + "','" + DateTime.Now.ToString("dd/MM/yyyy") + "'," + valor + "," + conta.NumeroConta + "," + conta.NumeroConta + ")";
cmd.CommandText = updateSaldoCaixa;
cmd.ExecuteNonQuery();
cmd.CommandText = sqlInsert;
cmd.ExecuteNonQuery();
cmd.CommandText = sqlUpdate;
cmd.ExecuteNonQuery();
// Attempt to commit the transaction.
transaction.Commit();
return(true);
}
catch (Exception ex)
{
try
{
transaction.Rollback();
return(false);
}
catch (Exception)
{
return(false);
}
finally
{
con.desconectar();
}
}
finally
{
con.desconectar();
}
}
static void Main(string[] args)
{
//var op = new Operacao(Somar);
Operacao op = Somar;
Console.WriteLine(op(2, 2));
op = Subtrair;
Console.WriteLine(op(2, 2));
Console.ReadKey();
}
private void AbreTelaBuscaOperacao()
{
var buscaOperacao = new fmBuscaOperacao();
buscaOperacao.ShowDialog();
if (buscaOperacao.operacaoSelecionada != null)
{
operacao = operacaoDAO.BuscaByID(buscaOperacao.operacaoSelecionada.OperacaoID);
PreencheCampos(operacao);
}
}
public FrmOrcamentoItem(Operacao op, model.SistemaHotelContext context, model.Orcamento orcamento, model.Orcamento_item orcamento_item)
{
InitializeComponent();
this._op = op;
this._context = context;
this._orcamento = orcamento;
this._orcamento_item = orcamento_item;
this._orcamento_itemRepositorio = new repositorio.Orcamento_itemRepositorio(_context);
Util.acertaTabOrder(this);
}
static void Main(string[] args)
{
Console.WriteLine("Thread {0}", Thread.CurrentThread.ManagedThreadId);
Operacao o = new Operacao(Somar);
Console.WriteLine("{0} - {1}", o.Method.Name, o(10, 5));
o = new Operacao(Subtrair);
Console.WriteLine("{0} - {1}", o.Method.Name, o.Invoke(10, 5));
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Thread {0}", Thread.CurrentThread.ManagedThreadId);
Operacao o = new Operacao(Somar);
IAsyncResult iar = o.BeginInvoke(10, 5, new AsyncCallback(OperacaoCompleta), "uma string qualquer");
while (!terminou)
{
Console.WriteLine(" aguardando...");
Thread.Sleep(500);
}
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Thread {0}", Thread.CurrentThread.ManagedThreadId);
Operacao o = new Operacao(Somar);
IAsyncResult iar = o.BeginInvoke(10, 5, new AsyncCallback(OperacaoCompleta), null);
while (!terminou)
{
Thread.Sleep(1000);
Console.WriteLine(" aguardando...");
}
Console.WriteLine("{0} - {1}", o.Method.Name, o.EndInvoke(iar));
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Thread {0}", Thread.CurrentThread.ManagedThreadId);
Operacao o = new Operacao(Somar);
IAsyncResult iar = o.BeginInvoke(10, 5, null, null);
Console.WriteLine("{0} - {1}", o.Method.Name, o.EndInvoke(iar));
o = new Operacao(Subtrair);
iar = o.BeginInvoke(10, 5, null, null);
Console.WriteLine("{0} - {1}", o.Method.Name, o.EndInvoke(iar));
Console.ReadKey();
}
static void Main(string[] args)
{
Console.WriteLine("Thread {0}", Thread.CurrentThread.ManagedThreadId);
Operacao o = new Operacao(Somar);
IAsyncResult iar = o.BeginInvoke(10, 5, null, null);
while (!iar.AsyncWaitHandle.WaitOne(1000, true))
Console.WriteLine(" aguardando...");
Console.WriteLine("{0} - {1}", o.Method.Name, o.EndInvoke(iar));
o = new Operacao(Subtrair);
iar = o.BeginInvoke(10, 5, null, null);
while (!iar.AsyncWaitHandle.WaitOne(5000, true))
Console.WriteLine(" aguardando...");
Console.WriteLine("{0} - {1}", o.Method.Name, o.EndInvoke(iar));
Console.ReadKey();
}
public virtual double Calcular(Operacao operacao, Corretora corretora)
{
return 1;
}
protected virtual void AntesClonar()
{
OperacaoAtual = Operacao.Incluir;
LerObjetoTela();
SetLastID();
}
protected virtual void AntesSalvar()
{
Operacao oldOperacao = OperacaoAtual;
Cursor.Current = Cursors.WaitCursor;
try
{
Salvar();
if (!Navegavel)
DoSelecionar(null);
else
{
DefinirDados();
OperacaoAtual = Operacao.Navegar;
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Erro", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
OperacaoAtual = oldOperacao;
}
finally
{
Cursor.Current = Cursors.Default;
}
}
private String traduzirOperacao(Operacao operacao)
{
switch (operacao)
{
case Operacao.ATRIBUICAO: return "=";
case Operacao.DIFERENCA: return "!=";
case Operacao.DIVISAO: return "/";
case Operacao.DIVISAO_ACUMULATIVA: return "/=";
case Operacao.E: return "&&";
case Operacao.IGUALDADE: return "==";
case Operacao.MAIOR: return ">";
case Operacao.MAIOR_IGUAL: return ">=";
case Operacao.MENOR: return "<";
case Operacao.MENOR_IGUAL: return "<=";
case Operacao.MODULO: return "%";
case Operacao.MODULO_ACUMULATIVO: return "%=";
case Operacao.MULTIPLICACAO: return "*";
case Operacao.MULTIPLICACAO_ACUMULATIVA: return "*=";
case Operacao.OU: return "||";
case Operacao.SOMA: return "+";
case Operacao.SOMA_ACUMULATIVA: return "+=";
case Operacao.SUBTRACAO: return "-";
case Operacao.SUBTRACAO_ACUMULATIVA: return "-=";
}
return null;
}
private void ExecutarAntesClonar()
{
if (AntesAlterar != null)
AntesAlterar(this);
if (antesCadastrar != null)
antesCadastrar(this);
_operacaoAtual = Operacao.Incluir;
}
internal void Salvar(Operacao v_oOperacao)
{
try
{
sbSQL.Length = 0;
sbSQL.Append(" UPDATE TBPRO020 SET DSAPLDOPRC =:DSAPLDOPRC, NMOPRC =:NMOPRC");
sbSQL.Append(" WHERE IDPRO020 =:IDPRO020");
sbSQL = TratarSQLParametroBanco(sbSQL.ToString());
oCmd = ObterCommand(sbSQL.ToString());
UtDbNet.AdicionarParametro(oCmd, TratarSQLParametroBanco("DSAPLDOPRC").ToString(), v_oOperacao.Apelido);
UtDbNet.AdicionarParametro(oCmd, TratarSQLParametroBanco("NMOPRC").ToString(), v_oOperacao.Nome);
UtDbNet.AdicionarParametro(oCmd, TratarSQLParametroBanco("IDPRO020").ToString(), v_oOperacao.Codigo);
oCmd.ExecuteNonQuery();
oCmd.Dispose();
}
catch (Exception ex)
{
throw new Dor.Util.OperacaoInvalidaBD(ex);
}
}
protected virtual void AntesClonar()
{
MarcarCampos(pnlCampos, false);
OperacaoAtual = Operacao.Incluir;
LerObjetoTela();
DefinirDetectorMudanca(true);
SetLastID();
}
internal void Obter(Operacao v_oOperacao, long v_iCodigo)
{
try
{
sbSQL.Length = 0;
sbSQL.Append(" SELECT DSAPLDOPRC, IDPRO020, NMOPRC");
sbSQL.Append(" FROM TBPRO020");
sbSQL.Append(" WHERE IDPRO020 =:IDPRO020");
sbSQL = TratarSQLParametroBanco(sbSQL.ToString());
oCmd = ObterCommand(sbSQL.ToString());
UtDbNet.AdicionarParametro(oCmd, TratarSQLParametroBanco("IDPRO020").ToString(), v_iCodigo);
oReader = oCmd.ExecuteReader();
if (oReader.Read())
{
v_oOperacao.Apelido = UtDbNet.CampoLiteral(oReader["DSAPLDOPRC"]);
v_oOperacao.Codigo = UtDbNet.CampoLongo(oReader["IDPRO020"]);
v_oOperacao.Nome = UtDbNet.CampoLiteral(oReader["NMOPRC"]);
}
oReader.Close();
oCmd.Dispose();
}
catch (Exception ex)
{
throw new Dor.Util.OperacaoInvalidaBD(ex);
}
}
protected virtual void AntesSalvar(bool SalvarTudo)
{
Operacao oldOperacao = OperacaoAtual;
Cursor.Current = Cursors.WaitCursor;
try
{
Salvar();
HabilitarSalvamento(false);
if (!Navegavel)
DoSelecionar(null);
else
{
if (SalvarTudo)
{
DefinirDados();
OperacaoAtual = Operacao.Navegar;
}
else
{
if (OperacaoAtual == Operacao.Incluir)
_operacaoAtual = Operacao.Alterar;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Erro", MessageBoxButtons.OKCancel, MessageBoxIcon.Error);
OperacaoAtual = oldOperacao;
}
finally
{
Cursor.Current = Cursors.Default;
}
}
private void menAcoesAdicionar_Click(object sender, EventArgs e)
{
OperacaoAtual = Operacao.Incluir;
}
private void menAcoesClonar_Click(object sender, EventArgs e)
{
if (dtgDados.Rows.Count > 0)
OperacaoAtual = Operacao.Clonar;
}
private void menAcoesRemover_Click(object sender, EventArgs e)
{
if (dtgDados.Rows.Count > 0)
OperacaoAtual = Operacao.Deletar;
}
private void menAcoesVisualizar_Click(object sender, EventArgs e)
{
OperacaoAtual = Operacao.Visualizar;
}
/// <summary>
/// redireciona para a página de sucesso
/// </summary>
/// <param name="funcionalidade"></param>
/// <param name="operacao"></param>
public void ExibirMensagemSucesso(Funcionalidade funcionalidade, Operacao operacao)
{
Response.Redirect(string.Format("~/Pages/Mensagem.aspx?result={0}&func={1}&op={2}", Resultado.Sucesso, funcionalidade, operacao), true);
}
protected virtual void AntesCancelar()
{
if (CheckSaida())
{
if (!Navegavel)
DoSelecionar(null);
else
{
DefinirDados();
OperacaoAtual = Operacao.Navegar;
}
}
}
