private async void Button_Clicked(object sender, EventArgs e)
{
Recado recado = new Recado
{
Assunto = edtAssunto.Text,
Cod_Emp = "001",
Descricao = edtMensagem.Text,
Destinatario = funcionario.Codigo,
Data_Cad = DateTime.Now,
Hora = DateTime.Now.ToString("HH:mm:ss"),
Remetente = app.getAcessKey("CODUSUARIO")
};
ApiCamareiraFacil api = new ApiCamareiraFacil();
if (!await api.GravaRecado(recado))
{
await DisplayAlert("Recado", "Não foi possível gravar recado", "OK");
}
else
{
await DisplayAlert("Recado", "Recado enviado com sucesso!", "OK");
await Navigation.PopAsync().ConfigureAwait(false);
}
}
public async Task <bool> GravaRecado(Recado itemRecado)
{
try
{
var jsonRecado = JsonConvert.SerializeObject(itemRecado);
using (var httpClient = new HttpClient())
{
HttpRequestMessage message = new HttpRequestMessage(HttpMethod.Post, BaseURL + "/datasnap/rest/TCamareiraFacilApi/GravaRecado");
message.Content = new StringContent(jsonRecado, Encoding.UTF8, "application/json");
HttpResponseMessage response = await httpClient.SendAsync(message);
if (response.IsSuccessStatusCode)
{
var teste = response.Content.ReadAsStringAsync().Result;
return(true);
}
}
return(false);
}
catch (Exception e)
{
throw e;
}
}
public void Excluir(int idUsuario, Recado model)
{
_repUsuario.PermissaoMensagem(idUsuario, _tipoPrograma, EnTipoManutencao.Excluir);
_rep.Excluir(model);
_rep.Commit();
}
public JsonResult DeleteConfirmed(int id)
{
bool result = false;
Recado recado = db.Recado.Find(id);
try
{
db.Recado.Remove(recado);
db.SaveChanges();
result = true;
ViewBag.ultimoRecado = db.Recado.OrderByDescending(x => x.IdRecado).FirstOrDefault();
if (ViewBag.ultimoRecado != null)
{
ViewBag.ultimoRecado = ViewBag.ultimoRecado.Substring(0, ViewBag.ultimoRecado.Length - 1);
ViewBag.ultimoRecado = ViewBag.ultimoRecado.Substring(0, ViewBag.ultimoRecado.Length - 1);;
}
else
{
ViewBag.ultimoRecado = null;
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception ex)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
}
private string TextoEmail(Recado model)
{
string ModoAbrEnc = "E";
string status = " (Encerrado)";
if (string.IsNullOrWhiteSpace(model.DescricaoFinal))
{
ModoAbrEnc = "A";
status = " (Aberto)";
}
var sb = new StringBuilder();
sb.AppendLine("Recado Sistema Domper: " + status);
sb.AppendLine("Id: " + model.Id.ToString("000000"));
sb.AppendLine("Data: " + model.Data.ToString() + " Hora: " + model.Hora.ToString());
sb.AppendLine("Usuário Lcto: " + model.UsuarioLcto.Nome);
sb.AppendLine("Nínvel: " + model.Nivel.ToString());
sb.AppendLine("Razão Social: " + model.Cliente.Nome);
sb.AppendLine("Endereco: " + model.Cliente.Endereco);
sb.AppendLine("Telefone: " + model.Cliente.Telefone);
sb.AppendLine("Contato: " + model.Contato);
sb.AppendLine("Usuário Destino: " + model.UsuarioDestino.Nome);
sb.AppendLine("Tipo: " + model.Tipo.Nome);
sb.AppendLine("Status: " + model.Status.Nome);
sb.AppendLine("Descrição:");
sb.AppendLine(model.DescricaoInicial);
if (ModoAbrEnc == "E")
{
sb.AppendLine("Descrição Encerramento: " + model.DescricaoFinal);
}
return(sb.ToString());
}
public void ObterRecadoParaAgrupamentoRetornarUmRecadoQuandoExistirMesmoNaoSendoOPrincipal()
{
//arrange
var recadoExistente = new Recado("Fulano", "Ciclano", "Primeiro recado", "Msg");
AlterarPropriedadeComReflection(recadoExistente, nameof(Recado.DataCriacao), DateTimeOffset.UtcNow.AddDays(-7 * 30));
_sut.Adicionar(recadoExistente);
var outroRecadoExistente = new Recado("Ciclano", "Fulano", "respondendo: Primeiro recado", "Msg", recadoExistente.Id);
AlterarPropriedadeComReflection(outroRecadoExistente, nameof(Recado.DataCriacao), DateTimeOffset.UtcNow.AddDays(-5 * 30));
_sut.Adicionar(outroRecadoExistente);
_ctx.DetachAllEntries();
var recadoInserir = new Recado("Ciclano", "Fulano", "respondendo: Primeiro recado", "");
//act
var recado = _sut.ObterRecadoParaAgrupamento(recadoInserir.Remetente, recadoInserir.Destinatario, recadoInserir.Assunto);
//assert
Assert.NotNull(recado);
Assert.Equal(outroRecadoExistente.Destinatario, recado.Destinatario);
Assert.Equal(outroRecadoExistente.Remetente, recado.Remetente);
Assert.Equal(outroRecadoExistente.Assunto, recado.Assunto);
Assert.Equal(outroRecadoExistente.Id, recado.Id);
Assert.Equal(outroRecadoExistente.Mensagem, recado.Mensagem);
}
public ActionResult NovoRecado(Recado recado)
{
recado.DataHora = DateTime.Now;
recado.RecadoID = ProxId++;
lista.Add(recado);
return(View());
}
public async Task CriacaoDeRecadoDeveAgruparQuandoForNecessario(Recado novoRecado, bool deveAgrupar)
{
//arrange
var recadoExistente = new Recado(1L, "Fulano", "Ciclano", "Primeiro recado", "");
_repo.ObterRecadoParaAgrupamento(novoRecado.Remetente, novoRecado.Destinatario, novoRecado.Assunto)
.Returns(deveAgrupar ? recadoExistente : default);
public void CriarAgrupamentoFalhaTest(Recado primeiroRecado, Recado segundoRecado)
{
var agrupamento = new Agrupamento();
agrupamento.AdicioneRecado(primeiroRecado);
Assert.False(agrupamento.RecadoPertenceAoAgrupamanto(segundoRecado));
}
public void Salvar(Recado model)
{
Validar(model);
_uow.RepositorioRecado.Salvar(model);
_uow.SaveChanges();
// TODO: tirar o comentario
EnviarEmailAoSalvar(model);
}
public void Salvar(Recado model)
{
Validar(model);
_rep.Salvar(model);
_rep.Commit();
// TODO: tirar o comentario
//EnviarEmailAoSalvar(model);
}
public void Excluir(Recado model, int idUsuario)
{
if (!_uow.RepositorioUsuario.PermissaoExcluir(idUsuario, _enProgramas))
{
throw new Exception(Mensagem.UsuarioSemPermissao);
}
_uow.RepositorioRecado.Deletar(model);
_uow.SaveChanges();
}
public ActionResult NovoRecado(Recado recado)
{
if (recado.Autor == null)
{
recado.Autor = "Anônimo";
}
recado.Horario = DateTime.Now;
recado.Mensagem = recado.Mensagem.Trim();
recados.Add(recado);
recado.RecadoID = recados.Select(r => r.RecadoID).Max() + 1;
return(RedirectToAction("Index"));
}
public static IRecado ObtenhaRecado()
{
var recado = new Recado
{
DataCriacao = DateTime.ParseExact("01/01/2019", ConstantesUtilitarios.DATA_PT_BR, CultureInfo.InvariantCulture),
Assunto = "Primeiro recado",
De = "Fulano",
Para = "Ciclano",
Mensagem = "Mensagem"
};
return(recado);
}
public void SalvarRecadoSemPreencherCamposObrigatoriosFalhaTest()
{
_controllerFixture.RestauraBanco();
var recado = new Recado();
_controller.ModelState.AddModelError(nameof(Recado.Assunto), string.Format(ConstantesPalavras.CAMPO_OBRIGATORIO, nameof(Recado.Assunto)));
var resultado = _controller.Cadastrar(recado);
var viewResult = Assert.IsType <ViewResult>(resultado);
Assert.IsAssignableFrom <Recado>(viewResult.ViewData.Model);
Assert.False(_controller.ModelState.IsValid);
Assert.True(_controller.ModelState.ContainsKey(nameof(Recado.Assunto)));
}
public void ObterRecadoParaAgrupamentoRetornarNullUmRecadoQuandoExistirMasDataCriacaoPassouDeSeisMeses()
{
//arrange
var recadoExistente = new Recado("Fulano", "Ciclano", "Primeiro recado", "Msg");
AlterarPropriedadeComReflection(recadoExistente, nameof(Recado.DataCriacao), DateTimeOffset.UtcNow.AddDays(-7 * 30));
_sut.Adicionar(recadoExistente);
_ctx.DetachAllEntries();
var recadoInserir = new Recado("Ciclano", "Fulano", "respondendo: Primeiro recado", "");
//act
var recado = _sut.ObterRecadoParaAgrupamento(recadoInserir.Remetente, recadoInserir.Destinatario, recadoInserir.Assunto);
//assert
Assert.Null(recado);
}
public ActionResult Create(Recado recado)
{
try
{
recado.dtPublicacao = System.DateTime.Now;
db.Recado.Add(recado);
db.SaveChanges();
ViewBag.ListaRecados = db.Recado.OrderByDescending(x => x.dtPublicacao).ToList();
ViewBag.ultimoRecado = db.Recado.OrderByDescending(x => x.IdRecado).FirstOrDefault();
return(View());
}
catch (Exception ex)
{
return(View());
}
}
public void ObterRecadoParaAgrupamentoRetornarUmRecadoQuandoExistir()
{
//arrange
var recadoExistente = new Recado("Fulano", "Ciclano", "Primeiro recado", "Msg");
_sut.Adicionar(recadoExistente);
_ctx.DetachAllEntries();
var recadoInserir = new Recado("Ciclano", "Fulano", "respondendo: Primeiro recado", "");
//act
var recado = _sut.ObterRecadoParaAgrupamento(recadoInserir.Remetente, recadoInserir.Destinatario, recadoInserir.Assunto);
//assert
Assert.NotNull(recado);
Assert.Equal(recadoExistente.Destinatario, recado.Destinatario);
Assert.Equal(recadoExistente.Remetente, recado.Remetente);
Assert.Equal(recadoExistente.Assunto, recado.Assunto);
Assert.Equal(recadoExistente.Id, recado.Id);
Assert.Equal(recadoExistente.Mensagem, recado.Mensagem);
}
public ActionResult Cadastrar(Recado recado)
{
try
{
ViewData["Titulo"] = ConstantesPalavras.CADASTRAR_RECADO;
if (ModelState.IsValid)
{
_agrupamentoServico.SalvarRecado(recado);
MensagemDeStatus = ConstantesPalavras.RECADO_CADASTRADO_SUCESSO;
return(RedirectToAction(nameof(Cadastrar)));
}
return(View(nameof(Cadastrar), recado));
}
catch (Exception ex)
{
Debug.WriteLine(string.Format(ConstantesPalavras.ERRO, ex.Message));
throw;
}
}
public Recado Editar(int idUsuario, int id, ref string permissaoMensagem)
{
bool permissao;
var model = new Recado();
model = _rep.ObterPorId(id);
var Usuario = _repUsuario.ObterPorId(idUsuario);
if (Usuario.Adm)
{
permissao = true;
permissaoMensagem = "OK";
}
else
{
permissao = _repUsuario.PermissaoUsuario(idUsuario, _tipoPrograma, EnTipoManutencao.Editar);
permissaoMensagem = permissao ? "OK" : "Usuário sem permissão!";
}
return(model);
}
public Recado Novo(int usuarioId)
{
_repUsuario.PermissaoMensagem(usuarioId, _tipoPrograma, EnTipoManutencao.Incluir);
var ServicoParametro = new ParametroServico();
var ServicoStatus = new StatusServico();
var ServicoTipo = new TipoServico();
var parametro = ServicoParametro.ObterPorParametro(43, 0);
var model = new Recado();
model.Data = DateTime.Now.Date;
model.Hora = TimeSpan.Parse(DateTime.Now.ToShortTimeString());
model.Nivel = 2;
model.UsuarioLcto = _repUsuario.ObterPorId(usuarioId);
model.Status = ServicoStatus.ObterPorCodigo(Convert.ToInt32(parametro.Valor));
model.Tipo = ServicoTipo.RetornarUmRegistroPrograma(EnTipos.Recado);
return(model);
}
public ActionResult GetDetalhe(int id)
{
Recado rec = lista.First <Recado>(r => r.RecadoID == id);
if (rec != null)
{
return(View(rec));
}
return(HttpNotFound());
/*
* foreach (Recado rec in lista)
* {
* if (rec.RecadoID == id)
* {
* return View(rec);
* }
* }
*
* return HttpNotFound();
*/
}
private void EnviarEmailAoSalvar(Recado model)
{
if (string.IsNullOrEmpty(model.ModoAbrEnc))
{
if (string.IsNullOrEmpty(model.DescricaoFinal))
{
model.ModoAbrEnc = "A";
}
else
{
model.ModoAbrEnc = "E";
}
}
if (model.ModoAbrEnc == "A")
{
EnviarEmail(model.UsuarioLctoId, model.UsuarioDestinoId, model.Id);
}
else
{
EnviarEmail(model.UsuarioDestinoId, model.UsuarioLctoId, model.Id);
}
}
public Recado Novo(int idUsuario)
{
if (!_uow.RepositorioUsuario.PermissaoIncluir(idUsuario, _enProgramas))
{
throw new Exception(Mensagem.UsuarioSemPermissao);
}
var parametro = _uow.RepositorioParametro.ObterPorParametro(43, 0);
int.TryParse(parametro.Valor, out int codigoStatus);
var model = new Recado
{
Data = DateTime.Now.Date,
Hora = TimeSpan.Parse(DateTime.Now.ToShortTimeString()),
Nivel = 2,
UsuarioLcto = _uow.RepositorioUsuario.find(idUsuario),
Status = _uow.RepositorioStatus.First(x => x.Codigo == codigoStatus),
Tipo = _uow.RepositorioTipo.RetornarUmRegistroPrograma(EnTipos.Recado)
};
return(model);
}
private void Validar(Recado model)
{
if (string.IsNullOrEmpty(model.RazaoSocial))
{
_uow.Notificacao.Add("Informe a Razão Social!");
}
if (model.TipoId == 0)
{
_uow.Notificacao.Add("Informe o Tipo!");
}
if (model.UsuarioLctoId == 0)
{
_uow.Notificacao.Add("Informe o Usuário Lançamento!");
}
if (model.UsuarioDestinoId == 0)
{
_uow.Notificacao.Add("Informe o Usuário Destino!");
}
if (model.StatusId == 0)
{
_uow.Notificacao.Add("Informe o Status!");
}
if (string.IsNullOrEmpty(model.DescricaoInicial))
{
_uow.Notificacao.Add("Informe a Descrição Inicial!");
}
if (!string.IsNullOrEmpty(model.DescricaoInicial))
{
if (model.Data > model.DataFinal)
{
_uow.Notificacao.Add("Data do Lançamento maior que Data do Encerramento!");
}
var parametro = _uow.RepositorioParametro.ObterPorParametro(44, 0);
if (parametro == null || string.IsNullOrEmpty(parametro.Valor))
{
_uow.Notificacao.Add("Informe o Status de Enceramento dos Recados nos parâmetros do Sistema!");
}
if (model.ModoAbrEnc == "E" && string.IsNullOrEmpty(model.DescricaoFinal))
{
_uow.Notificacao.Add("Informe a Descrição Final!");
}
if (!_uow.IsValid())
{
throw new Exception(_uow.RetornoNotificacao());
}
if (model.ModoAbrEnc == "E")
{
int.TryParse(parametro.Valor, out int codigoStatus);
var status = _uow.RepositorioStatus.First(x => x.Codigo == codigoStatus);
if (status != null)
{
model.StatusId = status.Id;
}
}
}
}
private void Validar(Recado model)
{
if (string.IsNullOrEmpty(model.RazaoSocial))
{
throw new Exception("Informe a Razão Social!");
}
if (model.TipoId == 0)
{
throw new Exception("Informe o Tipo!");
}
if (model.UsuarioLctoId == 0)
{
throw new Exception("Informe o Usuário Lançamento!");
}
if (model.UsuarioDestinoId == 0)
{
throw new Exception("Informe o Usuário Destino!");
}
if (model.StatusId == 0)
{
throw new Exception("Informe o Status!");
}
if (string.IsNullOrEmpty(model.DescricaoInicial))
{
throw new Exception("Informe a Descrição Inicial!");
}
if (!string.IsNullOrEmpty(model.DescricaoInicial))
{
if (model.Data > model.DataFinal)
{
throw new Exception("Data do Lançamento maior que Data do Encerramento!");
}
var ServicoParametro = new ParametroServico();
var parametro = ServicoParametro.ObterPorParametro(44, 0);
if (parametro == null || string.IsNullOrEmpty(parametro.Valor))
{
throw new Exception("Informe o Status de Enceramento dos Recados nos parâmetros do Sistema!");
}
if (model.ModoAbrEnc == "E" && string.IsNullOrEmpty(model.DescricaoFinal))
{
throw new Exception("Informe a Descrição Final!");
}
if (model.ModoAbrEnc == "E")
{
var status = _statusServico.ObterPorCodigo(Convert.ToInt32(parametro.Valor));
if (status != null)
{
model.StatusId = status.Id;
}
}
}
}
public void Excluir(Recado model)
{
_rep.Deletar(model);
}
public void Salvar(Recado model)
{
_rep.AddUpdate(model);
}
