public override ResultadoOperacao OnConsistirDados(BaseParaModel dados)
{
Cliente cliente = dados as Cliente;
ResultadoOperacao resultado = this.Validator.ConsistirNome(cliente.Nome);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_NOME;
return(resultado);
}
resultado = this.Validator.ConsistirDataNascimento(cliente.DataNascimento);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_DATA_NASCIMENTO;
return(resultado);
}
resultado = this.Validator.ConsistirCpf(cliente.Cpf);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_CPF;
return(resultado);
}
resultado = this.Validator.ConsistirSexo(cliente.Sexo);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_SEXO;
return(resultado);
}
return(new ResultadoSucesso());
}
private void TblUsuarios_CellContentClick(object sender, DataGridViewCellEventArgs e)
{
Usuario usuarioSelecionado = tblUsuarios.Rows[e.RowIndex].DataBoundItem as Usuario;
if (usuarioSelecionado == null)
{
return;
}
if (this.tblUsuarios.Columns[e.ColumnIndex] == this.tblUsuarios.Columns["btnEditar"])
{
MessageBox.Show("Chamaremos a tela de inclusão.", "Sistema Sebo", MessageBoxButtons.OK);
}
else if (this.tblUsuarios.Columns[e.ColumnIndex] == this.tblUsuarios.Columns["btnExcluir"])
{
if (MessageBox.Show("O usuário será excluído. Confirma a operação?", "Sistema Sebo", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
{
ResultadoOperacao resultado = this.Controller.Excluir(usuarioSelecionado);
if (resultado.VerificarSucessoOperacao())
{
CarregarTabela();
}
}
}
}
protected override void OnLostFocus(EventArgs e)
{
if (this.Text.Length == 0)
{
return;
}
LocalProduto localProduto = new LocalProduto
{
Descricao = this.Text
};
ResultadoOperacao resultado = Controller.Gravar(localProduto);
if (resultado.VerificarFalhaOperacao())
{
resultado.Exibir();
this.Text = "";
return;
}
this.LocalProdutoSelecionado = Controller.BuscarPelaDescricao(this.Text);
base.OnLostFocus(e);
}
// Método para salvar o item
public async Task <ResultadoOperacao> Salvar(Pessoa item)
{
ResultadoOperacao resultado = null;
// Verificar se é um novo item
bool novo = false;
if (item.Id == Guid.Empty)
{
item.Id = Guid.NewGuid();
novo = true;
}
// Salvar no repositório
resultado = await rep.SalvarAsync(item);
// Se executou com sucesso
if (resultado.Sucesso)
{
// Se for novo item
if (novo == true)
{
Lista.Add(item);
}
// Executar a chamada para o serviço
await srv.SalvarAsync(item, novo);
// Obter o resultado da execução
resultado = srv.Resultado;
}
return(resultado);
}
public ResultadoOperacao EnviarDenuncia(Denuncia denuncia)
{
try
{
denuncia daoDenuncia = ConvertDenunciaToDaoDenuncia(denuncia);
webserviceEntities model = new webserviceEntities();
denuncia addedDenuncia = model.denuncia.Add(daoDenuncia);
model.SaveChanges();
ResultadoOperacao resultado = new ResultadoOperacao();
if (addedDenuncia != null)
{
resultado.bSucesso = true;
resultado.iCodigo = addedDenuncia.id;
}
else
{
resultado.bSucesso = false;
}
return(resultado);
}
catch
{
ResultadoOperacao resultado = new ResultadoOperacao();
resultado.bSucesso = false;
return(resultado);
}
}
// Método para salvar o item
public async Task <ResultadoOperacao> Salvar(Evento item)
{
ResultadoOperacao resultado = null;
// Verificar se é um novo item
bool novo = false;
if (item.Id == Guid.Empty)
{
item.Id = Guid.NewGuid();
novo = true;
}
// Salvar no repositório
resultado = await rep.SalvarAsync(item);
// Se executou com sucesso
if (resultado.Sucesso)
{
// Se for novo item
if (novo == true)
{
Lista.Add(item);
}
// Continuará no futuro
}
return(resultado);
}
// Método para excluir o item
public async Task <ResultadoOperacao> Excluir(Pessoa item)
{
ResultadoOperacao resultado = null;
// Chamar o serviço para excluir
await srv.ExcluirAsync(item);
// Obter resultado da execução
resultado = srv.Resultado;
// Verificar se foi excluído com sucesso
if (resultado.Sucesso)
{
// Excliuir do repositório
resultado = await rep.ExcluirAsync(item);
// Se houve sucesso na exclusão
if (resultado.Sucesso)
{
// REmover da lista
Lista.Remove(item);
}
}
return(resultado);
}
public async Task <ResultadoOperacao> ExcluirAsync(Evento item)
{
var resultado = new ResultadoOperacao()
{
Sucesso = true
};
// Executar o comando para excluir
try
{
var qtd = await Conexao.DeleteAsync(item);
// Verificar se incluiu / alterou
if (qtd == 0)
{
resultado.Sucesso = false;
resultado.Mensagem = "Não foi possível excluir!";
}
}
catch (Exception ex)
{
resultado.Sucesso = false;
resultado.Mensagem = ex.Message;
}
return(resultado);
}
public async Task <ResultadoOperacao> SalvarAsync(Anotacao item)
{
// Verificar se é um novo registro
bool novo = (item.Id == 0);
// Obter o resultado da rotina de salvar
string retorno = await srv.SalvarAsync(item, novo);
// Obter o resultado da execução
ResultadoOperacao resultado = srv.Status;
// Verificar se o serviço foi executado com sucesso
if (resultado.Sucesso == true)
{
Anotacao itemsalvo = JsonConvert.
DeserializeObject <Anotacao>(retorno);
if (novo == true)
{
Lista.Add(itemsalvo);
}
}
return(resultado);
}
public async Task ExcluirAsync(Evento item)
{
// Inicializar o resultado da operação
Resultado = new ResultadoOperacao()
{
Sucesso = false
};
// Criar o parâmetro para requisição
var parametro = "?id=" + item.Id.ToString();
try
{
var resposta = await cliente.DeleteAsync(parametro);
// Verificar se houve sucesso na chamada
if (resposta.IsSuccessStatusCode)
{
Resultado.Sucesso = true;
}
else
{
// Obter as informações da requisição
Resultado.Mensagem = await resposta.Content.ReadAsStringAsync();
Resultado.NumeroErro = (int)resposta.StatusCode;
}
}
catch (Exception ex)
{
Resultado.Mensagem = ex.Message;
}
}
// InsertOrReplaceAsync = inclui ou altera um registro na tabela do banco de dados
public async Task <ResultadoOperacao> SalvarAsync(Pessoa item)
{
var resultado = new ResultadoOperacao()
{
Sucesso = true
};
// Executar o comando para salvar
try
{
var qtd = await Conexao.InsertOrReplaceAsync(item);
// Verificar se incluiu / alterou
if (qtd == 0)
{
resultado.Sucesso = false;
resultado.Mensagem = "Não foi possível salvar!";
}
}
catch (Exception ex)
{
resultado.Sucesso = false;
resultado.Mensagem = ex.Message;
}
return(resultado);
}
public override void TratarConsistencia(ResultadoOperacao retorno)
{
switch (retorno.Campo)
{
case LocalProdutoController.CAMPO_DESCRICAO: this.txtDescricao.Focus(); break;
}
}
public ResultadoOperacao Gravar(LocalProduto local)
{
ResultadoOperacao resultado = ConsistirDados(local);
if (resultado.VerificarFalhaOperacao())
{
return(resultado);
}
LocalProduto retorno = BuscarPelaDescricao(local.Descricao);
if (retorno == null)
{
if (ExibirQuestionamento(string.Format("O local {0} não existe no sistema. Deseja adicioná-lo?", local.Descricao), TipoQuestionamento.ExcetoTelaCadastro))
{
Context.LocaisProduto.Add(local);
Context.SaveChanges();
}
else
{
return(new ResultadoSilencioso());
}
}
return(new ResultadoSucesso());
}
public override ResultadoOperacao OnConsistirDados(BaseParaModel dados)
{
Usuario usuario = dados as Usuario;
ResultadoOperacao resultado = this.Validator.ConsistirLogin(usuario.Login);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_LOGIN;
return(resultado);
}
resultado = this.Validator.ConsistirSenha(usuario.Senha);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_SENHA;
return(resultado);
}
if (Context.Usuarios.Where(u => u.Login == usuario.Login).Count() > 0)
{
return(new ResultadoAviso("Este login já foi utilizado por outro usuário."));
}
return(new ResultadoSucesso());
}
public ResultadoOperacao ConsistirNovoItem(ItemVenda itemVenda)
{
ResultadoOperacao resultado = this.ItemVendaValidator.ConsistirPreco(itemVenda.Preco);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_ITEM_PRECO;
return(resultado);
}
resultado = this.ItemVendaValidator.ConsistirQuantidade(itemVenda.Quantidade);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_ITEM_QUANTIDADE;
return(resultado);
}
resultado = this.ItemVendaValidator.ConsistirDesconto(itemVenda.Desconto);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_ITEM_DESCONTO;
return(resultado);
}
return(new ResultadoSucesso());
}
public override void TratarConsistencia(ResultadoOperacao retorno)
{
switch (retorno.Campo)
{
case LoginController.CAMPO_LOGIN: this.txtLogin.Focus(); break;
case LoginController.CAMPO_SENHA: this.txtSenha.Focus(); break;
}
}
// Método para pesquisar o cep
public async Task <Endereco> Pesquisar(string cep)
{
// Declarar o objeto de retorno
Endereco end = null;
// Inicializar o resultado da chamada do serviço
Resultado = new ResultadoOperacao()
{
Sucesso = true
};
// Criar o parâmetro para a consulta
var parametro = cep + "/json";
try
{
// Chamar o serviço
var resposta = await cliente.GetAsync(parametro);
// Ler o conteúdo da resposta
var conteudo = await resposta.Content.ReadAsStringAsync();
// Verificar se executou com sucesso
if (resposta.IsSuccessStatusCode)
{
// Verificar se o serviço NÃO encontrou o cep
if (!conteudo.Contains("\"erro\": true"))
{
// Desserializar o endereço
end = JsonConvert.DeserializeObject <Endereco>(conteudo);
}
else
{
// Se não localizou o cep
Resultado.Sucesso = false;
Resultado.Mensagem = "CEP (" + cep + ") não localizado!";
}
}
else
{
// Se a execução NÃO foi realizada com sucesso.
Resultado.Sucesso = false;
Resultado.Mensagem = conteudo;
Resultado.NumeroErro = (int)resposta.StatusCode;
}
}
catch (Exception ex)
{
// Se ocorreu erro na execução
Resultado.Sucesso = false;
Resultado.Mensagem = ex.Message;
Resultado.NumeroErro = ex.HResult;
}
return(end);
}
public async Task <ResultadoOperacao> EnviarFoto(string nomeArquivo,
Stream foto)
{
// Método para enviar a foto para o servidor
Resultado = new ResultadoOperacao()
{
Sucesso = false
};
// Executar a ação
try
{
// Criar o conteúdo para envio
var dadosenvio = new MultipartFormDataContent();
//var teste = @"c:\caminho\arquivo.txt";
string nome = "\"Perfil\"";
string arquivo = string.Format("\"{0}\"", nomeArquivo);
var conteudo = new StreamContent(foto);
dadosenvio.Add(conteudo, nome, arquivo);
// Chamar o serviço para realizar o upload
await cliente.PostAsync("", dadosenvio).ContinueWith(task =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
// Obter a resposta
var resposta = task.Result;
// Verificar se executou com sucesso
if (resposta.IsSuccessStatusCode == true)
{
Resultado.Sucesso = true;
}
else
{
Resultado.NumeroErro = (int)resposta.StatusCode;
Resultado.Mensagem = string.Format("{0} - ({1})",
resposta.Content.ReadAsStringAsync().Result,
resposta.ReasonPhrase);
}
}
});
}
catch (Exception ex)
{
Resultado.Mensagem = ex.Message;
}
return(Resultado);
}
protected ResultadoOperacao ConsistirDados(BaseParaModel dados)
{
ResultadoOperacao retorno = OnConsistirDados(dados);
if (retorno.VerificarFalhaOperacao())
{
Tela.TratarConsistencia(retorno);
}
return(retorno);
}
/// <summary>
/// Exibe a mensagem de retorno da operação realizada.
/// </summary>
/// <param name="pResultadoOperacao">Resultado da operação.</param>
public void ExibirMensagemOperacao(ResultadoOperacao pResultadoOperacao)
{
if (pResultadoOperacao.Resultado != Enumeradores.Resultados.Sucesso)
{
this.ExibirMensagemErro(pResultadoOperacao);
this._logger.Error(pResultadoOperacao.TipoOperacao.ToString(), pResultadoOperacao.Excecao);
}
else
{
this.ExibirMensagemSucesso(pResultadoOperacao);
}
}
public override ResultadoOperacao OnConsistirDados(BaseParaModel dados)
{
Venda venda = dados as Venda;
ResultadoOperacao resultado = ConsistirItensVenda(venda.Itens);
if (resultado.VerificarFalhaOperacao())
{
return(resultado);
}
return(new ResultadoSucesso());
}
public async Task <Stream> ObterFoto(string nomeArquivo)
{
Resultado = new ResultadoOperacao()
{
Sucesso = false
};
// OU
//Resultado = new ResultadoOperacao();
//Resultado.Sucesso = false;
string parametro = "?filename=" + nomeArquivo;
Stream fotostream = null;
try
{
// Chamar o serviço para realizar o download
await cliente.GetAsync(parametro).ContinueWith(async task =>
{
if (task.Status == TaskStatus.RanToCompletion)
{
// Obter a resposta
var resposta = task.Result;
// Verificar se executou com sucesso
if (resposta.IsSuccessStatusCode == true)
{
// Obter o stream do arquivo
fotostream = await resposta.Content.
ReadAsStreamAsync();
Resultado.Sucesso = true;
}
else
{
Resultado.NumeroErro = (int)resposta.StatusCode;
Resultado.Mensagem = string.Format("{0} - ({1})",
resposta.Content.ReadAsStringAsync().Result,
resposta.ReasonPhrase);
}
}
});
}
catch (Exception ex)
{
Resultado.Mensagem = ex.Message;
}
return(fotostream);
}
public override ResultadoOperacao OnConsistirDados(BaseParaModel dados)
{
TipoProduto tipoProduto = dados as TipoProduto;
ResultadoOperacao resultado = this.Validator.ConsistirDescricao(tipoProduto.Descricao);
if (resultado.VerificarFalhaOperacao())
{
resultado.Campo = CAMPO_DESCRICAO;
return(resultado);
}
return(new ResultadoSucesso());
}
public ResultadoOperacao Gravar(Venda venda)
{
ResultadoOperacao resultado = ConsistirDados(venda);
if (resultado.VerificarFalhaOperacao())
{
return(resultado);
}
Context.Vendas.Add(venda);
Context.SaveChanges();
return(new ResultadoSucesso("Produto cadastrado com sucesso."));
}
public ResultadoOperacao Gravar(Cliente cliente)
{
ResultadoOperacao resultado = ConsistirDados(cliente);
if (resultado.VerificarFalhaOperacao())
{
return(resultado);
}
Context.Clientes.Add(cliente);
Context.SaveChanges();
return(new ResultadoSucesso("Cliente cadastrado com sucesso."));
}
public async Task <string> SalvarAsync(T item, bool ehNovo = false)
{
string resultado = null;
Status = new ResultadoOperacao()
{
Sucesso = false
};
try
{
var json = JsonConvert.SerializeObject(item);
var dadosenvio = new StringContent(json, Encoding.UTF8, Constantes.CONTEUDO_JSON);
HttpResponseMessage resposta = null;
if (ehNovo)
{
resposta = await cliente.PostAsync("", dadosenvio);
}
else
{
resposta = await cliente.PutAsync("", dadosenvio);
}
var conteudo = await resposta.Content.ReadAsStringAsync();
if (resposta.IsSuccessStatusCode)
{
resultado = conteudo;
Status.Sucesso = true;
//Debug.WriteLine(Constantes.MENSAGEM_SALVO_SUCESSO);
}
else
{
Status.Mensagem = conteudo;
Status.NumeroErro = (int)resposta.StatusCode;
}
}
catch (Exception ex)
{
Status.Mensagem = ex.Message;
//Debug.WriteLine(Constantes.MENSAGEM_ERRO_SALVAR, ex.Message);
}
return(resultado);
}
private void BtnGravar_Click(object sender, EventArgs e)
{
LocalProduto local = new LocalProduto()
{
Descricao = this.txtDescricao.Text
};
ResultadoOperacao resultado = Controller.Gravar(local);
if (resultado.VerificarSucessoOperacao())
{
Limpar();
}
resultado.Exibir();
}
public ResultadoOperacao SacarDinheiro(decimal quantia)
{
ResultadoOperacao resultado =
ResultadoOperacao.OperacaoIniciada;
if (saldo < quantia)
{
Console.WriteLine("Saldo insuficiente.");
return(ResultadoOperacao.SaldoInsuficiente);
}
resultado = Sacar(quantia);
ImprimirComprovante();
return(resultado);
///<image url="$(ProjectDir)\img3.png"/>
}
// Método para excluir o item
public async Task <ResultadoOperacao> Excluir(Evento item)
{
ResultadoOperacao resultado = null;
// Excliuir do repositório
resultado = await rep.ExcluirAsync(item);
// Se houve sucesso na exclusão
if (resultado.Sucesso)
{
// REmover da lista
Lista.Remove(item);
}
return(resultado);
}
public ResultadoOperacao Gravar(Usuario usuario, Image foto)
{
ResultadoOperacao resultado = ConsistirDados(usuario);
if (resultado.VerificarFalhaOperacao())
{
return(resultado);
}
usuario.Foto = ConverterImagemParaArquivo(foto);
Context.Usuarios.Add(usuario);
Context.SaveChanges();
return(new ResultadoSucesso("Usuário cadastrado com sucesso."));
}
