public async Task <IActionResult> Delete(Guid id)
{
if (await IsLoginInvalid())
{
MensagemDTO mensagem = new MensagemDTO("Não autorizado!");
return(Unauthorized(mensagem));
}
if (id == null)
{
MensagemDTO mensagem = new MensagemDTO
("Conteúdo não encontrado! Verifique se o id está correto e tente novamente");
return(NotFound(mensagem));
}
try
{
await UsuarioRepository.DeleteAsync(id);
return(Ok());
}
catch (Exception Ex)
{
MensagemDTO mensagemDTO = new MensagemDTO(Ex.Message);
return(BadRequest(mensagemDTO));
}
}
public async Task <string> Cadastrar(MensagemDTO mensagemDto)
{
var chamado = await _unitOfWork.ChamadoRepositorio.Consultar(mensagemDto.ChamadoId);
var usuario = await _unitOfWork.UsuarioRepositorio.Consultar(mensagemDto.UsuarioId);
if (chamado != null && usuario != null && !string.IsNullOrEmpty(mensagemDto.Conteudo))
{
var mensagem = new Mensagem();
mensagem.Conteudo = mensagemDto.Conteudo;
mensagem.ChamadoId = mensagemDto.ChamadoId;
mensagem.DataCriacao = DateTime.Now;
mensagem.UsuarioId = mensagemDto.UsuarioId;
await _unitOfWork.MensagemRepositorio.Adicionar(mensagem);
await _unitOfWork.Commit();
return(mensagem.Id);
}
else
{
return(null);
}
}
public async Task <IActionResult> Put(Guid id, [FromBody] UsuarioDTO usuarioDTO)
{
if (id != usuarioDTO.Id)
{
MensagemDTO message = new MensagemDTO("Erro na alteração: ids diferentes!");
return(BadRequest(message));
}
if (await IsLoginInvalid())
{
MensagemDTO mensagem = new MensagemDTO("Não autorizado!");
return(Unauthorized(mensagem));
}
try
{
var usuario = _mapper.Map <Usuario>(usuarioDTO);
await UsuarioRepository.UpdateAsync(usuario);
return(Ok(usuarioDTO));
}
catch (Exception Ex)
{
MensagemDTO mensagemDTO = new MensagemDTO(Ex.Message);
return(BadRequest(mensagemDTO));
}
}
public void InserirMensagemDB(MensagemDTO mensagem)
{
try
{
IDbCommand inserirCmd = conexao.CreateCommand();
//inserirCmd.CommandText = "insert into Mensagem values('Bom dia! Tudo bem?',1,2)";
//inserirCmd.CommandText = "insert into Mensagem (Mensagem, Grupo, PaiMensagem) values(@Mensagem, @Grupo, @PaiMensagem)";
inserirCmd.CommandText = "insert into Mensagem (Mensagem, Grupo, PaiMensagem,ContSyncronia,PaiSyncronia) values(@Mensagem, @Grupo, @PaiMensagem, @ContSyncronia, @PaiSyncronia)";
IDbDataParameter paraMensagem = new SqlParameter("Mensagem", mensagem.Mensagem);
inserirCmd.Parameters.Add(paraMensagem);
IDbDataParameter paraGrupo = new SqlParameter("Grupo", mensagem.Grupo);
inserirCmd.Parameters.Add(paraGrupo);
IDbDataParameter paraPaiMensagem = new SqlParameter("PaiMensagem", mensagem.PaiMensagem);
inserirCmd.Parameters.Add(paraPaiMensagem);
IDbDataParameter paraContSyncronia = new SqlParameter("ContSyncronia", mensagem.ContSyncronia);
inserirCmd.Parameters.Add(paraContSyncronia);
IDbDataParameter paraPaiSyncronia = new SqlParameter("PaiSyncronia", mensagem.PaiSyncronia);
inserirCmd.Parameters.Add(paraPaiSyncronia);
inserirCmd.ExecuteNonQuery();
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conexao.Close();
}
}
public List <MensagemDTO> ListarMensagensDB()
{
var listaMensagens = new List <MensagemDTO>();
try
{
IDbCommand selectCmd = conexao.CreateCommand();
selectCmd.CommandText = "select * from Mensagem";
IDataReader resultado = selectCmd.ExecuteReader();
while (resultado.Read())
{
var mensagen = new MensagemDTO()
{
Id = Convert.ToInt32(resultado["Id"]),
Mensagem = Convert.ToString(resultado["Mensagem"]),
Grupo = Convert.ToInt32(resultado["Grupo"]),
PaiMensagem = Convert.ToInt32(resultado["PaiMensagem"]),
ContSyncronia = Convert.ToInt32(resultado["ContSyncronia"]),
PaiSyncronia = Convert.ToInt32(resultado["PaiSyncronia"])
};
listaMensagens.Add(mensagen);
}
return(listaMensagens);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conexao.Close();
}
}
public async Task <IActionResult> Login([FromBody] LoginUserDTO userInfo)
{
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(user.Email,
userInfo.Password, isPersistent : false, lockoutOnFailure : false);
if (result.Succeeded)
{
var userDto = _mapper.Map <UsuarioDTO>(user);
UsuarioTokenDTO aux = GeraToken(userDto);
await UsuarioRepository.UpdateToken(user, aux.Token);
return(Ok(aux));
}
else
{
MensagemDTO message = new MensagemDTO("Senha inválida!");
return(Unauthorized(message));
}
}
else
{
MensagemDTO message = new MensagemDTO("Usuário e/ou senha inválidos");
return(Unauthorized(message));
}
}
public async Task <IActionResult> Logout()
{
await _signInManager.SignOutAsync();
MensagemDTO mensagem = new MensagemDTO("Logout com sucesso!");
return(Ok(mensagem));
}
public void EnviarMensagem(MensagemDTO mensagemDTO)
{
try
{
_servicoDAO.EnviarMensagem(mensagemDTO);
}
catch (System.Exception ex)
{
throw new SystemException(ex.Message);
}
}
public void EnviarMensagem(MensagemDTO mensagemDTO)
{
Mensagem novaMensagem = new Mensagem
{
PostId = mensagemDTO.PostId,
Name = mensagemDTO.Name.ToLower(),
Email = mensagemDTO.Email,
Body = mensagemDTO.Body.ToLower()
};
_context.CollectionMensagem.InsertOne(novaMensagem);
}
public ActionResult <Mensagem> EnviarMensagem(MensagemDTO mensagemDTO)
{
try
{
_servicoBll.EnviarMensagem(mensagemDTO);
return(Ok());
}
catch (System.Exception ex)
{
throw new SystemException(ex.Message);
}
}
public void FormataTexBoxReceberMensagens2(List <MensagemDTO> mensagens)
{
try
{
if (!PodeRefreshTextMensagem(mensagens))
{
return;
}
panelDeMensagens.Controls.Clear();
int espaco = 20;
int posicao = 25;
int tamanhoLista = mensagens.Count;
for (int i = tamanhoLista - 1; i >= 0; i--)
{
if (!this.Visible)
{
return;
}
MensagemDTO obj = mensagens[i];
if (obj.Id > UlitmoId)
{
UlitmoId = obj.Id;
}
if (obj.PaiMensagem == 1)
{
posicao = FormatacaoTamanhoLabel(obj.Mensagem, posicao, true, espaco, false);
}
else
{
posicao = FormatacaoTamanhoLabel(obj.Mensagem, posicao, false, espaco, true);
}
}
if (AtualizarBarra)
{
panelDeMensagens.AutoScrollPosition = new Point(0, 189);
if (panelDeMensagens.VerticalScroll.Visible)
{
panelDeMensagens.VerticalScroll.Value = 189;
}
}
else
{
panelDeMensagens.AutoScrollPosition = new Point(0, panelDeMensagens.VerticalScroll.Maximum);
}
}
catch (Exception)
{
throw;
}
AtualizarBarra = false;
}
public async Task <IActionResult> NovaMensagem([FromBody] MensagemDTO mensagemDto)
{
try
{
var mensagemId = await _mensagemService.Cadastrar(mensagemDto);
return(Ok(JsonConvert.SerializeObject(mensagemId)));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task SendMensagemAsync([FromBody] MensagemDTO msg)
{
/* ENVIA PRA POLLY */
var audio = await _serv.PegaAudioPolly(msg.Corpo);
/* Grava no S3*/
var link = await _serv.SalvaAudioNoS3(audio);
/* COLOCA NO SQS o link */
//await _serv.PoeLinkAudioNaFilaDoSQS(link);
await _serv.SalvaMensagemBanco(link, msg.Corpo, msg.UsuarioId, msg.CaminhaoId, msg.Sender);
}
public IHttpActionResult Post([FromBody] MensagemDTO mensagenDTO)
{
try
{
MensagenModel mensagen = new MensagenModel();
mensagen.InserirMensagem(mensagenDTO);
return(Ok("Mensagem enviada!"));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public void SalvarMensagem(string mensagem)
{
MensagemDAO pegarSync = new MensagemDAO();
int MinhaUltimaSync = pegarSync.PegarDadosUltimaSincronia();
MensagemDAO mensagemDAO = new MensagemDAO();
MensagemDTO mensagemDTO = new MensagemDTO();
mensagemDTO.Mensagem = mensagem;
mensagemDTO.Id = 1;
mensagemDTO.PaiMensagem = 1;
mensagemDTO.Grupo = 1;
mensagemDTO.PaiSyncronia = 1;
mensagemDTO.ContSyncronia = MinhaUltimaSync + 1;
mensagemDAO.SalvarMensagem(mensagemDTO);
}
public void InserirMensagem(MensagemDTO mensagem)
{
try
{
//MensagemDAO pegarSync = new MensagemDAO();
//int MinhaUltimaSync = pegarSync.PegarDadosUltimaSincronia(mensagem.PaiSyncronia, mensagem.Grupo);
MensagemDAO mensagemDAO = new MensagemDAO();
//mensagem.ContSyncronia = MinhaUltimaSync + 1;
mensagemDAO.InserirMensagemDB(mensagem);
//MensagemDAO mensagemDAO = new MensagemDAO();
//mensagemDAO.InserirMensagemDB(mensagem);
}
catch (Exception e)
{
throw new Exception($"Erro ao inserir Mensagem: {e.Message}");
}
}
public List <MensagemDTO> PegarDadosParaEnviarSincronia(SincronizadorDTO objSinc)
{
try
{
conexao.Open();
List <MensagemDTO> listaDeMensagens = new List <MensagemDTO>();
foreach (GrupoSincronizadoresPaiDTO obj in objSinc.ListaDeGruposSincroniaPay)
{
foreach (PaiSincronia objPaisSinc in obj.SincroniasPai)
{
IDbCommand selectCmd = conexao.CreateCommand();
selectCmd.CommandText = "select * from Mensagem where Grupo = " + obj.IdGrupo + " and PaiSyncronia = " + objPaisSinc.Id + " and ContSyncronia > " + objPaisSinc.MaxSincronia;
IDataReader resultado = selectCmd.ExecuteReader();
while (resultado.Read())
{
var mensagem = new MensagemDTO()
{
Id = Convert.ToInt32(resultado["Id"]),
Mensagem = Convert.ToString(resultado["Mensagem"]),
Grupo = Convert.ToInt32(resultado["Grupo"]),
PaiMensagem = Convert.ToInt32(resultado["PaiMensagem"]),
ContSyncronia = Convert.ToInt32(resultado["ContSyncronia"]),
PaiSyncronia = Convert.ToInt32(resultado["PaiSyncronia"])
};
listaDeMensagens.Add(mensagem);
}
conexao.Close();
conexao.Open();
}
}
return(listaDeMensagens);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conexao.Close();
}
}
public List <MensagemDTO> ObterTodasMensagens()
{
List <MensagemDTO> mensagemDTOs = new List <MensagemDTO>();
var mensage = _context.CollectionMensagem.Find <Mensagem>(mens => true).ToList();
foreach (var item in mensage)
{
MensagemDTO mensagemDTO = new MensagemDTO
{
PostId = item.PostId,
Id = item.Id,
Name = item.Name,
Email = item.Email,
Body = item.Body
};
mensagemDTOs.Add(mensagemDTO);
}
return(mensagemDTOs);
}
public async Task <IActionResult> GetAll()
{
var usuarios = await UsuarioRepository.GetAllAsync();
if (await IsLoginInvalid())
{
MensagemDTO mensagem = new MensagemDTO("Não autorizado!");
return(Unauthorized(mensagem));
}
if (usuarios == null)
{
MensagemDTO mensagemDTO = new MensagemDTO("Operação inválida! Tente adicionar mais usuários!");
return(BadRequest(mensagemDTO));
}
var usuarioResumoDTOs = _mapper.Map <IEnumerable <UsuarioResumoDTO> >(usuarios);
return(Ok(usuarioResumoDTOs));
}
public async Task <IActionResult> GetAsyncById(Guid id)
{
var usuario = await UsuarioRepository.GetAsync(id);
if (await IsLoginInvalid())
{
MensagemDTO mensagem = new MensagemDTO("Não autorizado!");
return(Unauthorized(mensagem));
}
if (usuario == null)
{
MensagemDTO mensagemDTO = new MensagemDTO("Usuário não encontrado!");
return(NotFound(mensagemDTO));
}
var usuarioDTO = _mapper.Map <UsuarioDTO>(usuario);
return(Ok(usuarioDTO));
}
private Activity HandleSystemMessage(Activity message)
{
if (message.Type == ActivityTypes.DeleteUserData)
{
// Implement user deletion here
// If we handle user deletion, return a real message
}
else if (message.Type == ActivityTypes.ConversationUpdate)
{
var saudacao = _saudacaoService.RecuperaSaudacaoInicial();
Activity reply = message.CreateReply(saudacao.Texto);
ConnectorClient connector = new ConnectorClient(new Uri(message.ServiceUrl));
StateClient stateClient = message.GetStateClient();
BotData userData = stateClient.BotState.GetUserData(message.ChannelId, message.From.Id);
userData = stateClient.BotState.GetUserData(message.ChannelId, message.From.Id);
var mensagemTemp = new MensagemDTO {
TipoFaseBot = TipoFaseBot.Saudacao, Texto = saudacao.Texto
};
userData.SetProperty <MensagemDTO>("Mensagem", mensagemTemp);
stateClient.BotState.SetUserData(message.ChannelId, message.From.Id, userData);
connector.Conversations.ReplyToActivity(reply);
}
else if (message.Type == ActivityTypes.ContactRelationUpdate)
{
// Handle add/remove from contact lists
// Activity.From + Activity.Action represent what happened
}
else if (message.Type == ActivityTypes.Typing)
{
// Handle knowing tha the user is typing
}
else if (message.Type == ActivityTypes.Ping)
{
}
return(null);
}
public List <MensagemDTO> GetMensagensToList(int usuarioId, int caminhaoId)
{
var msgs = _rep.GetMensagensToList(usuarioId, caminhaoId);
List <MensagemDTO> listMsgsDTO = new List <MensagemDTO>();
foreach (Mensagem msg in msgs)
{
MensagemDTO msgDTO = new MensagemDTO()
{
CaminhaoId = msg.CaminhaoId,
Corpo = msg.Corpo,
DataHora = msg.DataHora,
LinkAudio = msg.LinkAudio,
Sender = msg.Sender,
UsuarioId = msg.UsuarioId,
};
listMsgsDTO.Add(msgDTO);
}
return(listMsgsDTO);
}
public SincronizadorDTO PegarMensagensNaoSincronizadas(SincronizadorDTO listaMensagemSinc)
{
List <MensagemDTO> listaMensagens = new List <MensagemDTO>();
try
{
conexao = new SqlConnection(stringConexao);
conexao.Open();
IDbCommand selectCmd = conexao.CreateCommand();
selectCmd.CommandText = "select * from mensagem where grupo = 1 and ContSyncronia > 1";
IDataReader resultado = selectCmd.ExecuteReader();
while (resultado.Read())
{
var mensagen = new MensagemDTO()
{
Id = Convert.ToInt32(resultado["Id"]),
Mensagem = Convert.ToString(resultado["Mensagem"]),
Grupo = Convert.ToInt32(resultado["Grupo"]),
PaiMensagem = Convert.ToInt32(resultado["PaiMensagem"]),
ContSyncronia = Convert.ToInt32(resultado["ContSyncronia"]),
PaiSyncronia = Convert.ToInt32(resultado["PaiSyncronia"])
};
listaMensagens.Add(mensagen);
}
listaMensagemSinc.ListaMensagem = listaMensagens;
return(listaMensagemSinc);
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
finally
{
conexao.Close();
}
}
public async Task <IActionResult> Register([FromBody] RegisterUserDTO userInfo)
{
if (await UsuarioRepository.GetByEmailAsync(userInfo.Email) != null)
{
MensagemDTO mensagem = new MensagemDTO("Já existe um usuário com esse email cadastrado!");
return(Conflict(mensagem));
}
var user = new Usuario
{
UserName = userInfo.Email,
Name = userInfo.Name,
Email = userInfo.Email,
EmailConfirmed = true,
DDD = userInfo.Phone.DDD,
PhoneNumber = userInfo.Phone.Number,
PhoneNumberConfirmed = true
};
var result = await _userManager.CreateAsync(user, userInfo.Password);
if (!result.Succeeded)
{
MensagemDTO message = new MensagemDTO("Não foi possível registrar esse usuário!");
return(BadRequest(message));
}
await _signInManager.SignInAsync(user, false);
var userDto = _mapper.Map <UsuarioDTO>(user);
UsuarioTokenDTO aux = GeraToken(userDto);
await UsuarioRepository.UpdateToken(user, aux.Token);
return(Ok(aux));
}
public SincronizadorDTO Teste2Sincronizador()
{
SincronizadorDTO sincronizador = new SincronizadorDTO();
sincronizador.StatusSincroniaMensagem = Status.Solicitando;
//sincronizador.MaxSincMensagem = 1;
//sincronizador.MaxSincUsuario = 1;
//sincronizador.MaxSincContatos = 1;
List <MensagemDTO> listaMensagem = new List <MensagemDTO>();
MensagemDTO m1 = new MensagemDTO()
{
Id = 2,
Mensagem = "Teste2",
Grupo = 1,
PaiMensagem = 1,
PaiSyncronia = 1,
ContSyncronia = 2
};
listaMensagem.Add(m1);
MensagemDTO m2 = new MensagemDTO()
{
Id = 3,
Mensagem = "Teste3",
Grupo = 1,
PaiMensagem = 1,
PaiSyncronia = 1,
ContSyncronia = 3
};
listaMensagem.Add(m2);
MensagemDTO m3 = new MensagemDTO()
{
Id = 4,
Mensagem = "Teste4",
Grupo = 1,
PaiMensagem = 1,
PaiSyncronia = 1,
ContSyncronia = 4
};
listaMensagem.Add(m3);
//sincronizador.ListaMensagem = listaMensagem;
sincronizador.ListaMensagem = null;
UsuarioDTO us = new UsuarioDTO();
us = null;
sincronizador.ListaUsuarios.Add(us);
ContatoDTO ct = new ContatoDTO();
ct = null;
sincronizador.ListaContatos.Add(ct);
GrupoSincronizadoresPaiDTO Gs = new GrupoSincronizadoresPaiDTO();
Gs.IdGrupo = 1;
PaiSincronia sp1 = new PaiSincronia();
sp1.Id = 1;
sp1.MaxSincronia = 1;
Gs.SincroniasPai.Add(sp1);
PaiSincronia sp2 = new PaiSincronia();
sp2.Id = 2;
sp2.MaxSincronia = 2;
Gs.SincroniasPai.Add(sp2);
sincronizador.ListaDeGruposSincroniaPay.Add(Gs);
return(sincronizador);
}