public HttpResponseMessage Remover(int cursoId)
{
//Localiza o curso pelo Id
var curso = _context.CursoSet.Find(cursoId);
//Se o curso não for localizado, retorna o erro
if (curso == null)
{
Notificacoes.Add("Curso não Localizado.");
return(CriarResposta(HttpStatusCode.NotFound));
}
//Verifica se o curso possui alunos matriculados
if (curso.AlunosMatriculadosNoCurso.Count > 0)
{
Notificacoes.Add("Curso não pode ser excluído, pois existem aluno(s) matriculado(s).");
return(CriarResposta(HttpStatusCode.BadRequest));
}
//Confirmando a Exclusão
_context.CursoSet.Remove(curso);
_context.SaveChanges();
return(CriarResposta(HttpStatusCode.OK, new
{
Mensagem = "Curso removido com sucesso."
}));
}
public ActionResult Create([Bind(Include = "idDemandaFinal,Produto_produtor_idProduto_produtor,Produto_armazem_idProduto_armazem,ano_pedido,mes_pedido,dia_pedido,quantidade")] DemandaFinal_produtor demandaFinal_produtor)
{
int.TryParse(Session["idUsuario"].ToString(), out int idUsuario);
Produto_armazem prodarm = db.Produto_armazem.Find(demandaFinal_produtor.Produto_armazem_idProduto_armazem);
int idUser = prodarm.Usuario_idUsuario;
Usuario userResp = db.Usuario.Find(idUser);
demandaFinal_produtor.Usuario_idUsuario = userResp.idUsuario;
demandaFinal_produtor.status_demanda = 1;
if (ModelState.IsValid)
{
var notificacao = new Notificacoes {
idUsuario = idUsuario, textoNotificacao = "Há uma nova demanda!"
};
db.Notificacoes.Add(notificacao);
db.DemandaFinal_produtor.Add(demandaFinal_produtor);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Usuario_idUsuario = new SelectList(db.Usuario, "idUsuario", "nome_usuario", demandaFinal_produtor.Usuario_idUsuario);
ViewBag.Produto_armazem_idProduto_armazem = new SelectList(db.Produto_armazem, "idProduto_armazem", "nome_prodA", demandaFinal_produtor.Produto_armazem_idProduto_armazem);
ViewBag.Produto_produtor_idProduto_produtor = new SelectList(db.Produto_produtor, "idProduto_produtor", "nome_prodP", demandaFinal_produtor.Produto_produtor_idProduto_produtor);
ViewBag.status_demanda = new SelectList(db.StatusDemanda, "idDemandaFinal", "nome_status", demandaFinal_produtor.status_demanda);
return(View(demandaFinal_produtor));
}
public void AssinarNotificacao(Notificacoes notificacao)
{
if (!PossuiAssinatura(notificacao))
{
MeiosNotificacoes.Add(notificacao);
}
}
public void UpdateStatus(StatusPagamentoEnum status)
{
if (status == StatusPagamentoEnum.AGUARDANDO_PAGAMENTO && !(Id > 0))
{
Status = StatusPagamentoEnum.AGUARDANDO_PAGAMENTO;
}
else if (status == StatusPagamentoEnum.PAGAMENTO_APROVADO && Status == StatusPagamentoEnum.AGUARDANDO_PAGAMENTO)
{
Status = StatusPagamentoEnum.PAGAMENTO_APROVADO;
}
else if (status == StatusPagamentoEnum.ENVIADO_PARA_TRANSPORTADORA && Status == StatusPagamentoEnum.PAGAMENTO_APROVADO)
{
Status = StatusPagamentoEnum.ENVIADO_PARA_TRANSPORTADORA;
}
else if (status == StatusPagamentoEnum.ENTREGUE && Status == StatusPagamentoEnum.ENVIADO_PARA_TRANSPORTADORA)
{
Status = StatusPagamentoEnum.ENTREGUE;
}
else if (status == StatusPagamentoEnum.CANCELADA && (Status == StatusPagamentoEnum.AGUARDANDO_PAGAMENTO || Status == StatusPagamentoEnum.PAGAMENTO_APROVADO))
{
Status = StatusPagamentoEnum.CANCELADA;
}
else
{
Notificacoes.Add("Status inválido");
}
}
new public async Task <Pessoa> Inserir(Pessoa item)
{
if (!item.Telefones.Any())
{
Notificacoes.Add(new Erro(
Contatos.Notificacoes.Enum.CriticidadeEnum.Media,
"Telefones",
"Atenção deve haver ao menos um telefone!",
Contatos.Notificacoes.Enum.CamadaEnum.Dominio, null));
}
if (!item.Emails.Any())
{
Notificacoes.Add(new Erro(
Contatos.Notificacoes.Enum.CriticidadeEnum.Media,
"Emails",
"Atenção deve haver ao menos um email!",
Contatos.Notificacoes.Enum.CamadaEnum.Dominio, null));
}
if (Notificacoes.Any())
{
return(null);
}
return(await _pessoaRepository.Inserir(item));
}
public async Task <IActionResult> put(int NotificacaoId, Notificacoes model)
{
try
{
//verifica se existe aluno a ser alterado
var notif = await this.Repo.GetNotificacaoById(NotificacaoId);
if (notif == null)
{
return(NotFound());
}
this.Repo.Entry(notif);
this.Repo.Update(model);
if (await this.Repo.SaveChangesAsync())
{
//pegar o aluno novamente, agora alterado para devolver pela rota abaixo
//video = await this.Repo.GetVideoByID(VideoId);
//return Created($"/api/videos/{model.Id}", model);
return(Ok());
}
}
catch
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Falha no acesso ao banco de dados."));
}
// retorna BadRequest se não conseguiu alterar
return(BadRequest());
}
public void AddNotificacoes(string message)
{
if (Notificacoes == null)
{
Notificacoes = new List <string>();
}
Notificacoes.Add(message);
}
public void AdicionarNotificacao(string notificacao)
{
if (Notificacoes == null)
{
Notificacoes = new List <string>();
}
Notificacoes.Add(notificacao);
}
public async Task <PessoaViewModel> IncluirPessoa(PessoaViewModel pessoa)
{
var cliVal = new PessoaValid(pessoa);
if (!cliVal.Evalido)
{
Notificacoes.AddRange(cliVal.Notificacoes);
return(null);
}
var pessoaAdd = new Pessoa
{
Ativo = true,
Email = pessoa.Email,
Nome = pessoa.Nome,
Telefone = pessoa.Telefone,
};
if (pessoa.Emails.Any())
{
pessoaAdd.Emails = pessoa.Emails.Select(x => new Email
{
Ativo = true,
Id = Guid.NewGuid(),
EnderecoEmail = x.EnderecoEmail
}).ToList();
}
if (pessoa.Telefones.Any())
{
pessoaAdd.Telefones = pessoa.Telefones.Select(x => new Telefone {
Ativo = true,
Id = Guid.NewGuid(),
NumeroTelefone = x.NumeroTelefone
}).ToList();
}
var pessAdded = await _pessoaService.Inserir(pessoaAdd);
if (_pessoaService.Notificacoes.Any())
{
Notificacoes.AddRange(_pessoaService.Notificacoes);
return(null);
}
return(new PessoaViewModel
{
Id = pessAdded.Id.ToString(),
Email = pessAdded.Email,
Nome = pessAdded.Nome,
Telefone = pessAdded.Telefone,
Telefones = pessAdded.Telefones.Any() ? pessAdded.Telefones.Select(x => new TelefoneViewModel {
Id = x.Id.ToString(), NumeroTelefone = x.NumeroTelefone, Ativo = x.Ativo
}) : new List <TelefoneViewModel>(),
Emails = pessAdded.Emails.Any() ? pessAdded.Emails.Select(x => new EmailViewModel {
Ativo = x.Ativo, EnderecoEmail = x.EnderecoEmail, Id = x.Id.ToString()
}) : new List <EmailViewModel>()
});
}
public ClienteController(ILogger <ClienteController> logger, IClienteService clienteService, Notificacoes notificacoes, IMapper mapper, IClienteRepository clienteRepository)
: base(notificacoes)
{
_logger = logger;
_clienteService = clienteService;
_notificacoes = notificacoes;
_mapper = mapper;
_clienteRepository = clienteRepository;
}
public bool Validate()
{
if (Usuario == null)
{
AdicionarNotificacao("UsuarioLogin", "O usuario é requerido para efeturar uma venda");
}
return(!Notificacoes.Any());
}
public void UpdateIdVendedor(int idVendedor)
{
if (idVendedor <= 0)
{
Notificacoes.Add("Vendedor inválido");
}
IdVendedor = idVendedor;
}
public void UpdateItens(List <VendaItem> itens)
{
if (!itens.Any())
{
Notificacoes.Add("A lista de itens deve estar preenchida");
}
VendaItens = itens;
}
public ModeloTableNotificacoes NotificacoesToModelTable(Notificacoes not)
{
ModeloTableNotificacoes mtn = new ModeloTableNotificacoes()
{
PartitionKey = not.Mensagem,
RowKey = not.Data
};
return(mtn);
}
public Notificacoes ModeloTableToNotificacoes(ModeloTableNotificacoes notificacoes)
{
Notificacoes n = new Notificacoes()
{
Mensagem = notificacoes.PartitionKey,
Data = notificacoes.RowKey
};
return(n);
}
public HttpResponseMessage AdicionarOuAtualizar(Aluno aluno)
{
//Validando se o objeto aluno recebido não é nulo
if (aluno == null)
{
Notificacoes.Add("Aluno não Informado.");
return(CriarResposta(HttpStatusCode.BadRequest));
}
//Validando se o Nome do aluno não é Nulo, Vazio ou se tem mais de 100 caracteres
if (string.IsNullOrEmpty(aluno.Nome))
{
Notificacoes.Add("Nome Obrigatório.");
}
else
{
if (aluno.Nome.Length > 100)
{
Notificacoes.Add("Nome deve ter no máximo 100 caracteres");
}
}
//Validando se o sexo do aluno não é Nulo ou Vazio
if (string.IsNullOrEmpty(aluno.Sexo))
{
Notificacoes.Add("Sexo Obrigatório.");
}
//Localiza o curso pelo Id
var curso = _context.CursoSet.Find(aluno.CursoId);
//Se o curso não for localizado, retorna o erro
if (curso == null)
{
Notificacoes.Add("Curso não localizado.");
}
//Se tiver erros retorna os erros e não adiciona ou altera o aluno
if (Notificacoes.Count > 0)
{
return(CriarResposta(HttpStatusCode.BadRequest));
}
//Setar o curso no aluno
aluno.Curso = curso;
//Salvando os dados
_context.AlunoSet.AddOrUpdate(aluno);
_context.SaveChanges();
return(CriarResposta(HttpStatusCode.Created, new
{
Mensagem = "Aluno adicionado / alterado com sucesso."
}));
}
public ActionResult FinalizarColeta(int?coletaId)
{
if (coletaId == null)
{
string mensagem = "Id da coleta não informado!";
return(RedirectToAction("Erro", "Home", new { Mensagem = mensagem }));
}
Coletas c = db.Coletas.Find(coletaId);
if (c == null)
{
string mensagem = "Coleta não encontrada!";
return(RedirectToAction("Erro", "Home", new { Mensagem = mensagem }));
}
List <Notificacoes> notificacoes = new List <Notificacoes>();
foreach (var cc in c.ClientesColetas)
{
if (cc.coletado == "A")
{
cc.coletado = "N";
foreach (var m in cc.MateriaisColetados)
{
m.coletado = "N";
}
}
Notificacoes n = new Notificacoes()
{
clienteId = cc.Clientes.clienteId,
coletaId = c.coletaId,
cooperativaId = c.cooperativaId,
dataHorario = DateTime.Now,
descricao = "Coleta do dia " + c.horaAgendada.Value.ToShortDateString() +
" - " + c.horaAgendada.Value.ToShortTimeString() + " foi finalizada.",
ativa = true,
tipo = "A"
};
notificacoes.Add(n);
}
c.coletado = "F";
db.Notificacoes.AddRange(notificacoes);
db.SaveChanges();
return(RedirectToAction("DetalheColeta", "Cooperativas", new { id = coletaId }));
}
//---------------------------NOTIFICACOES----------------------------------
public void AdicionarNotificao(string message)
{
Notificacoes not = new Notificacoes()
{
Mensagem = message,
Data = Guid.NewGuid().ToString()
};
try
{
table.Execute(TableOperation.InsertOrReplace(NotificacoesToModelTable(not)));
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public override async Task <bool> IsSatisfiedBy(T candidate)
{
var Satisfied = await base.IsSatisfiedBy(candidate);
if (Notificacoes.Any())
{
_notificacoes.AddRange(Notificacoes);
return(Satisfied);
}
if (candidate is EntityBase)
{
AtualizarDadosEntitty(candidate as EntityBase);
}
return(Satisfied);
}
public async Task <IActionResult> post(Notificacoes modelo)
{
try
{
this.Repo.Add(modelo);
if (await this.Repo.SaveChangesAsync())
{
return(Ok());
//return Created($"/api/{modelo.Id}", modelo);
}
}
catch
{
return(this.StatusCode(StatusCodes.Status500InternalServerError, "Falha no acesso ao banco de dados."));
}
return(BadRequest());
}
public void Cliente_Apagar_NaoEncontrou_RetornoInvalido()
{
//Arrange
var mockRepository = new Mock <IClienteRepository>(MockBehavior.Strict);
Notificacoes notificacoes = new Notificacoes();
IClienteService clienteService = new ClienteService(mockRepository.Object, notificacoes);
mockRepository.Setup(s => s.ObterPorCpfCnpj(clienteNovo.CpfCnpj)).Returns(clienteNull);
mockRepository.Setup(s => s.Apagar(clienteNovo.CpfCnpj));
mockRepository.Setup(s => s.SaveChanges()).Returns(1);
//Act
clienteService.Apagar(clienteNovo.CpfCnpj);
//Assert
Assert.True(notificacoes.TemNotificacao());
mockRepository.Verify(mock => mock.ObterPorCpfCnpj(clienteNovo.CpfCnpj), Times.Once);
mockRepository.Verify(mock => mock.Apagar(clienteNovo.CpfCnpj), Times.Never);
mockRepository.Verify(mock => mock.SaveChanges(), Times.Never);
}
public bool Validate()
{
if (Login == null)
{
AdicionarNotificacao("Login", "O login é obrigatório");
}
if (Login.Length < 3 || Login.Length > 30)
{
AdicionarNotificacao("Login", "O login precisa ter no mínimo 3 e no máximo 30 caracteres");
}
if (Senha == null)
{
AdicionarNotificacao("Senha", "A senha é obrigatória");
}
if (Senha.Length < 6 || Senha.Length >= 24)
{
AdicionarNotificacao("Senha", "A senha precisa ter no mínimo 6 e no máximo 24 caracteres");
}
return(!Notificacoes.Any());
}
public HttpResponseMessage Remover(int alunoId)
{
//Localiza o aluno pelo Id
var aluno = _context.AlunoSet.Find(alunoId);
//Se o aluno não for localizado, retorna o erro
if (aluno == null)
{
Notificacoes.Add("Aluno não Localizado.");
return(CriarResposta(HttpStatusCode.NotFound));
}
//Confirmando a Exclusão
_context.AlunoSet.Remove(aluno);
_context.SaveChanges();
return(CriarResposta(HttpStatusCode.OK, new
{
Mensagem = "Aluno removido com sucesso."
}));
}
public bool Validate()
{
if (Nome == null)
{
AdicionarNotificacao("NomeProd", "O campo nome é obrigatório");
}
if (Nome.Length < 3 || Nome.Length > 80)
{
AdicionarNotificacao("NomeProd", "O nome do produto deve ter entre 3 e 80 caracteres");
}
if (Codigo.ToString().Length > 24)
{
AdicionarNotificacao("Codigo", "O codigo do produto pode ter no máximo 24 caracteres");
}
if (PrecoCusto <= 0)
{
AdicionarNotificacao("Preco", "O preço de custo não pode ser zero");
}
return(!Notificacoes.Any());
}
public void Cliente_NaoDeveIncluir_CpfInvalido_RetornoValido()
{
//Arrange
var mockRepository = new Mock <IClienteRepository>(MockBehavior.Strict);
Notificacoes notificacoes = new Notificacoes();
IClienteService clienteService = new ClienteService(mockRepository.Object, notificacoes);
mockRepository.Setup(s => s.ObterPorCpfCnpj(clienteInValido.CpfCnpj)).Returns(clienteNull);
mockRepository.Setup(s => s.Adicionar(clienteInValido)).Returns(clienteInValido);
mockRepository.Setup(s => s.SaveChanges()).Returns(1);
//Act
clienteValido = clienteService.Adicionar(clienteInValido);
//Assert
Assert.True(!clienteValido.IsValid);
Assert.True(notificacoes.TemNotificacao());
mockRepository.Verify(mock => mock.ObterPorCpfCnpj(clienteNovo.CpfCnpj), Times.Never);
mockRepository.Verify(mock => mock.Adicionar(clienteNovo), Times.Never);
mockRepository.Verify(mock => mock.SaveChanges(), Times.Never);
}
public void Cliente_Alterar_RetornoValido()
{
//Arrange
var mockRepository = new Mock <IClienteRepository>(MockBehavior.Strict);
Notificacoes notificacoes = new Notificacoes();
IClienteService clienteService = new ClienteService(mockRepository.Object, notificacoes);
mockRepository.Setup(s => s.ObterPorCpfCnpj(clienteValido.CpfCnpj)).Returns(clienteValido);
mockRepository.Setup(s => s.Alterar(clienteValido)).Returns(clienteValido);
mockRepository.Setup(s => s.SaveChanges()).Returns(1);
//Act
clienteValido = clienteService.Alterar(clienteValido);
//Assert
Assert.True(clienteValido.IsValid);
Assert.True(!notificacoes.TemNotificacao());
mockRepository.Verify(mock => mock.ObterPorCpfCnpj(clienteValido.CpfCnpj), Times.Once);
mockRepository.Verify(mock => mock.Alterar(clienteValido), Times.Once);
mockRepository.Verify(mock => mock.SaveChanges(), Times.Once);
}
public FiltroDeParametroLatitudeAsync(Notificacoes notificacoes)
{
_notificacoes = notificacoes;
}
public FiltroDeParametroObrigatorioGTINAsync(Notificacoes notificacoes)
{
_notificacoes = notificacoes;
}
public bool PossuiAssinatura(Notificacoes notificacao) => MeiosNotificacoes.Any(x => x == notificacao);
public void Add(Notificacao notificacao)
{
Notificacoes.Add(notificacao);
}
