public IHttpActionResult Delete(int id)
{
try
{
var entityInDb = _usuarioClienteBusiness.GetById(id);
//Verifica se objeto existe
if (entityInDb == null)
{
return(NotFound());
}
if (_usuarioClienteBusiness.Delete(id))
{
//Monta response
_result = Ok(Retorno <bool> .Criar(true, "Deleção Realizada Com Sucesso", true));
//Retorna o response
return(_result);
}
else
{
return(BadRequest("Nenhum registro deletado. Verifique os dados enviados."));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult DoRecover([FromBody] RecoverRequest recoverRequest)
{
using (var responseMsg = new HttpResponseMessage())
{
IHttpActionResult result;
try
{
//Se o email enviado é null, retornar BadRequest
if (recoverRequest == null)
{
return(BadRequest("Dados inválidos."));
}
var userLogin = new UserLogin {
Email = recoverRequest.Email, UserType = recoverRequest.UserType
};
//Recupera o usuário de atendimento
var recoverResponse = _loginBusiness.DoRecover(userLogin);
//Monta response
result = Ok(Retorno <RecoverResponse> .Criar(true, "Recuperação de Senha Realizada Com Sucesso.", recoverResponse));
//Retorna o response com o token
return(result);
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
}
public IHttpActionResult Insert([FromBody] UsuarioClienteRequest request)
{
try
{
//Valida objeto
if (!ModelState.IsValid)
{
return(BadRequest("Dados inválidos."));
}
var entity = Mapper.Map <UsuarioClienteRequest, UsuarioCliente>(request);
_usuarioClienteBusiness.Insert(ref entity);
if (entity.Id > 0)
{
//Monta response
_result = Ok(Retorno <UsuarioClienteResponse> .Criar(true, "Inclusão Realizada Com Sucesso", Mapper.Map <UsuarioCliente, UsuarioClienteResponse>(entity)));
}
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult DeleteList([FromBody] int[] list)
{
try
{
IList <Anexo> entityList = new List <Anexo>();
try
{
if (list != null && list.Length > 0)
{
foreach (var id in list)
{
var entityInDb = _anexoBusiness.GetById(id);
//Verifica se objeto existe
if (entityInDb == null)
{
return(BadRequest("Nenhum registro deletado. Verifique os dados enviados."));
}
else
{
entityList.Add(entityInDb);
}
}
if (_anexoBusiness.Delete(entityList))
{
//Monta response
_result = Ok(Retorno <bool> .Criar(true, "Deleção de Lista Realizada Com Sucesso", true));
//Retorna o response
return(_result);
}
else
{
return(BadRequest("Nenhum registro deletado. Verifique os dados enviados."));
}
}
else
{
return(BadRequest("Nenhum registro deletado. Verifique os dados enviados."));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult Authenticate([FromBody] LoginRequest loginRequest)
{
using (var responseMsg = new HttpResponseMessage())
{
IHttpActionResult result;
try
{
//Se os dados do login estão null, retornar BadRequest
if (loginRequest == null)
{
return(BadRequest("Dados inválidos."));
}
var userLogin = new UserLogin {
UserName = loginRequest.Username, Password = loginRequest.Password, UserType = loginRequest.UserType
};
//Recupera o usuário de atendimento
var loginResponse = _loginBusiness.DoLogin(userLogin);
//Se o usuário não foi encontrado com base nos dados do login, retornar Unauthorized
if (loginResponse == null)
{
return(BadRequest("Login não autorizado."));
}
//Cria a token de autenticação e autorização
if (loginRequest.UserType == Tipos.Login.Atendimento)
{
loginResponse.Token = CreateToken(loginRequest.Username.ToLower(), ((AtendenteEmpresa)loginResponse.Usuario).Email);
}
else
{
loginResponse.Token = CreateToken(loginRequest.Username.ToLower(), ((UsuarioCliente)loginResponse.Usuario).Email);
}
//Monta response
result = Ok(Retorno <LoginResponse> .Criar(true, "Acesso Autorizado", loginResponse));
//Retorna o response com o token
return(result);
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
}
//[AllowAnonymous]
public IHttpActionResult UpdateList(IEnumerable <TicketUpdate> list)
{
IList <Ticket> entityList = new List <Ticket>();
try
{
//Valida objeto
if (!ModelState.IsValid)
{
return(BadRequest("Dados inválidos."));
}
foreach (var item in list)
{
var entityInDb = _ticketBusiness.GetById(item.Id);
//Verifica se objeto existe
if (entityInDb == null)
{
return(BadRequest("Nenhum registro atualizado. Verifique os dados enviados."));
}
else
{
Mapper.Map(item, entityInDb);
entityInDb.DataHoraAlteracao = DateTime.Now;
entityList.Add(entityInDb);
}
}
if (_ticketBusiness.Update(entityList))
{
//Monta response
_result = Ok(Retorno <bool> .Criar(true, "Atualização de Lista Realizada Com Sucesso", true));
//Retorna o response
return(_result);
}
else
{
return(BadRequest("Nenhum registro atualizado. Verifique os dados enviados."));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[AllowAnonymous]
public IHttpActionResult GetTotalAtendentesEmpresa(int idEmpresa)
{
try
{
//Recupera o total de registros de tickets associados a um usuario
var total = _empresaBusiness.GetTotalAtendentesEmpresa(idEmpresa);
//Monta response
_result = Ok(Retorno <int> .Criar(true, "Consulta Realizada Com Sucesso", total));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[AllowAnonymous]
public IHttpActionResult GetCount(int idCliente)
{
try
{
//Recupera o total de registros de usuarios associados ao cliente
var total = _usuarioClienteBusiness.GetCount(idCliente);
//Monta response
_result = Ok(Retorno <int> .Criar(true, "Consulta Realizada Com Sucesso", total));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[Authorize]
public IHttpActionResult GetCounts(int idCliente)
{
try
{
//Recupera todos os totais de registros de tickets
var response = _ticketBusiness.GetCounts(idCliente);
//Monta response
_result = Ok(Retorno <CountsResponse> .Criar(true, "Consulta Realizada Com Sucesso", response, response.Totais.Count()));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[AllowAnonymous]
public IHttpActionResult GetCount(int idStatusTicket)
{
try
{
//Recupera o total de registros de tickets de acordo com o filtro informado
var total = _ticketBusiness.GetCount(idStatusTicket);
//Monta response
_result = Ok(Retorno <int> .Criar(true, "Consulta Realizada Com Sucesso", total));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult GetAllById(int idCliente)
{
try
{
var lista = _usuarioClienteBusiness.GetAllById(idCliente).ToList().Select(Mapper.Map <UsuarioCliente, UsuarioClienteResponse>);
var totalRegistros = lista.Count();
//Monta response
_result = Ok(Retorno <IEnumerable <UsuarioClienteResponse> > .Criar(true, "Consulta Realizada Com Sucesso", lista, totalRegistros, totalRegistros));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult GetAll()
{
try
{
//Mapeia os dados da fonte (source class) para o destino (destiny class)
var lista = _atendenteEmpresaBusiness.GetAll().ToList().Select(Mapper.Map <AtendenteEmpresa, AtendenteEmpresaResponse>);
var totalRegistros = lista.Count();
//Monta response
_result = Ok(Retorno <IEnumerable <AtendenteEmpresaResponse> > .Criar(true, "Consulta Realizada Com Sucesso", lista, totalRegistros, totalRegistros));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult GetAllByTicketId(TicketMensagensRequest request)
{
try
{
//Mapeia os dados da fonte (source class) para o destino (destiny class)
IEnumerable <TicketMensagemResponse> lista = _ticketMensagemBusiness.GetAllByTicketId(request).ToList();
var totalRegistros = lista.Count();
//Monta response
_result = Ok(Retorno <IEnumerable <TicketMensagemResponse> > .Criar(true, "Consulta Realizada Com Sucesso", lista, totalRegistros, totalRegistros));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[AllowAnonymous]
public IHttpActionResult Update(int id, [FromBody] TicketRequest request)
{
try
{
//Valida objeto
if (!ModelState.IsValid)
{
return(BadRequest("Dados inválidos."));
}
var entityInDb = _ticketBusiness.GetById(id);
//Verifica se objeto existe
if (entityInDb == null)
{
return(NotFound());
}
//Mapeio os dados do dto para o objeto recuperado do banco, atualizando os dados do objeto do banco
Mapper.Map(request, entityInDb);
entityInDb.DataHoraAlteracao = DateTime.Now;
if (_ticketBusiness.Update(entityInDb))
{
//Monta response
_result = Ok(Retorno <Ticket> .Criar(true, "Atualização Realizada Com Sucesso", entityInDb));
//Retorna o response
return(_result);
}
else
{
return(BadRequest("Nenhum registro atualizado. Verifique os dados enviados."));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult GetAllPaged(FilterUsuarioRequest advancedFilter)
{
try
{
var result = _usuarioClienteBusiness.GetAllPaged(advancedFilter);
var lista = result.Usuarios.ToList().Select(Mapper.Map <UsuarioCliente, UsuarioClienteResponse>);
var totalGeral = result.TotalGeral;
var totalLinhas = lista.Count();
//Monta response
_result = Ok(Retorno <IEnumerable <UsuarioClienteResponse> > .Criar(true, "Consulta Realizada Com Sucesso", lista, totalGeral));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[AllowAnonymous]
public IHttpActionResult InsertList(IEnumerable <TicketRequest> list)
{
IList <Ticket> entityList = new List <Ticket>();
try
{
//Valida objeto
if (!ModelState.IsValid)
{
return(BadRequest("Dados inválidos."));
}
foreach (var item in list)
{
var entity = Mapper.Map <TicketRequest, Ticket>(item);
entity.DataHoraInicial = DateTime.Now;
entityList.Add(entity);
}
var rows = _ticketBusiness.Insert(entityList);
if (rows > 0)
{
//Monta response
_result = Ok(Retorno <int> .Criar(true, "Inclusão de Lista Realizada Com Sucesso", rows));
//Retorna o response
return(_result);
}
else
{
return(BadRequest("Nenhum registro inserido. Verifique os dados enviados."));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[AllowAnonymous]
public IHttpActionResult GetById(TicketFilledRequest ticketRequest)
{
try
{
var entity = _ticketBusiness.GetByIdFilled(ticketRequest.Id, ticketRequest.WithAnexos);
if (entity == null)
{
return(NotFound());
}
//Monta response
_result = Ok(Retorno <TicketResponse> .Criar(true, "Consulta Realizada Com Sucesso", entity));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult GetById(int id)
{
try
{
var entity = _usuarioClienteBusiness.GetById(id);
if (entity == null)
{
return(NotFound());
}
//Monta response
_result = Ok(Retorno <UsuarioClienteResponse> .Criar(true, "Consulta Realizada Com Sucesso", Mapper.Map <UsuarioCliente, UsuarioClienteResponse>(entity)));
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult ChangePassword([FromBody] ChangePasswordRequest changePasswordRequest)
{
AtendenteEmpresa atendente = null;
UsuarioCliente usuario = null;
using (var responseMsg = new HttpResponseMessage())
{
IHttpActionResult result = null;
try
{
//Se o email enviado é null, retornar BadRequest
if (changePasswordRequest == null)
{
return(BadRequest("Dados inválidos."));
}
if (changePasswordRequest.UserType == Tipos.Login.Atendimento)
{
atendente = _atendenteEmpresaBusiness.GetByUsernameAndPassword(changePasswordRequest.Username, changePasswordRequest.OldPassword);
if (atendente != null)
{
atendente.Password = changePasswordRequest.NewPassword;
atendente.Provisorio = false;
if (_atendenteEmpresaBusiness.UpdatePassword(atendente))
{
atendente.Password = "******";
//Monta response
result = Ok(Retorno <AtendenteEmpresa> .Criar(true, "Troca de Senha Realizada Com Sucesso.", atendente));
}
}
}
else
{
usuario = _usuarioClienteBusiness.GetByUsernameAndPassword(changePasswordRequest.Username, changePasswordRequest.OldPassword);
if (usuario != null)
{
usuario.Password = changePasswordRequest.NewPassword;
usuario.Provisorio = false;
if (_usuarioClienteBusiness.UpdatePassword(usuario))
{
usuario.Password = "******";
//Monta response
result = Ok(Retorno <UsuarioCliente> .Criar(true, "Troca de Senha Realizada Com Sucesso.", usuario));
}
}
}
//Retorna o response com o token
return(result);
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
}
//[AllowAnonymous]
public IHttpActionResult UpdateClassificacao([FromBody] TicketUpdateClassificacaoRequest request)
{
AtendenteEmpresa atendenteEmpresa = null;
List <AtendenteEmpresa> listaAtendentes = null;
try
{
//Valida objeto
if (!ModelState.IsValid)
{
return(BadRequest("Dados inválidos."));
}
var entityInDb = _ticketBusiness.GetById(request.Id);
//Verifica se objeto existe
if (entityInDb == null)
{
return(NotFound());
}
entityInDb.IdClassificacao = request.IdClassificacao;
entityInDb.DataHoraAlteracao = DateTime.Now;
if (_ticketBusiness.Update(entityInDb))
{
//Recupera o ticket atualizado
entityInDb = _ticketBusiness.GetById(request.Id);
//Monta response
_result = Ok(Retorno <Ticket> .Criar(true, "Atualização Realizada Com Sucesso", entityInDb));
//===========================================================================================
//Enviar email de atualização do atendimento
//===========================================================================================
var usuarioCliente = _usuarioClienteBusiness.GetById(request.IdUsuarioCliente);
var classificacao = _classificacaoBusiness.GetById(entityInDb.IdClassificacao);
if (request.UserTypeAgent == "S")
{
atendenteEmpresa = _atendenteEmpresaBusiness.GetById(request.IdAtendente);
if (atendenteEmpresa != null)
{
if (atendenteEmpresa.Copia)
{
listaAtendentes = _atendenteEmpresaBusiness.GetList(x => x.IdEmpresa == atendenteEmpresa.IdEmpresa && x.Id != atendenteEmpresa.Id).ToList();
}
}
}
try
{
_ticketBusiness.EnviarEmailConfirmacao(request.UserTypeAgent, null, classificacao, entityInDb, usuarioCliente, atendenteEmpresa, listaAtendentes, nameof(classificacao));
}
catch (Exception)
{
//Monta response
_result = Ok(Retorno <Ticket> .Criar(true, "Atualização Realizada Com Sucesso - Email de confirmação não enviado", entityInDb));
}
//===========================================================================================
//Retorna o response
return(_result);
}
else
{
return(BadRequest("Nenhum registro atualizado. Verifique os dados enviados."));
}
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
//[AllowAnonymous]
public IHttpActionResult Insert([FromBody] TicketRequest request)
{
UsuarioCliente usuarioCliente = null;
AtendenteEmpresa atendenteEmpresa = null;
List <AtendenteEmpresa> listaAtendentes = null;
try
{
//Valida objeto
if (!ModelState.IsValid)
{
return(BadRequest("Dados inválidos."));
}
var entity = Mapper.Map <TicketRequest, Ticket>(request);
var pathAnexosUsuario = request.PathAnexos;
entity.DataHoraInicial = DateTime.Now;
_ticketBusiness.Insert(ref entity);
if (entity.Id > 0)
{
//Monta response
_result = Ok(Retorno <TicketResponse> .Criar(true, "Inclusão Realizada Com Sucesso", Mapper.Map <Ticket, TicketResponse>(entity)));
//Trata dos anexos
if (Directory.Exists(pathAnexosUsuario))
{
//Zipa todos os anexos
var zipName = Arquivo.Compress(ConfigurationManager.AppSettings["CaminhoFisicoAnexo"], pathAnexosUsuario, entity.Id);
//======================================
//Guarda anexo (zip) no banco de dados
//======================================
var anexo = new Anexo
{
IdTicket = entity.Id,
Nome = zipName
};
_anexoBusiness.Insert(ref anexo);
}
//===========================================================================================
//Enviar email de confirmação de criação do novo atendimento
//===========================================================================================
var ticketResponse = _ticketBusiness.GetByIdFilled(entity.Id, false);
if (request.UserTypeAgent == "S")
{
usuarioCliente = _usuarioClienteBusiness.GetById(request.IdUsuarioCliente);
atendenteEmpresa = _atendenteEmpresaBusiness.GetById(request.IdAtendente);
if (atendenteEmpresa != null)
{
if (atendenteEmpresa.Copia)
{
listaAtendentes = _atendenteEmpresaBusiness.GetList(x => x.IdEmpresa == atendenteEmpresa.IdEmpresa && x.IdEmpresa != atendenteEmpresa.IdEmpresa).ToList();
}
}
}
else
{
usuarioCliente = _usuarioClienteBusiness.GetById(request.IdUsuarioCliente);
listaAtendentes = _atendenteEmpresaBusiness.GetAll(ticketResponse.UsuarioCliente.Cliente.IdEmpresa).ToList();
}
var statusTicket = _statusTicketBusiness.GetById(request.IdStatusTicket);
try
{
_ticketBusiness.EnviarEmailConfirmacao(request.UserTypeAgent, statusTicket, null, entity, usuarioCliente, atendenteEmpresa, listaAtendentes, "insert");
}
catch (Exception)
{
//Monta response
_result = Ok(Retorno <TicketResponse> .Criar(true, "Inclusão Realizada Com Sucesso - Email de confirmação não enviado", Mapper.Map <Ticket, TicketResponse>(entity)));
}
//===========================================================================================
}
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}
public IHttpActionResult Insert([FromBody] TicketMensagemRequest request)
{
UsuarioCliente usuarioCliente = null;
AtendenteEmpresa atendenteEmpresa = null;
Ticket ticket = null;
List <AtendenteEmpresa> listaAtendentes = null;
try
{
//Valida objeto
if (!ModelState.IsValid)
{
return(BadRequest("Dados inválidos."));
}
var entity = Mapper.Map <TicketMensagemRequest, TicketMensagem>(request);
var pathAnexosUsuario = request.PathAnexos;
ticket = _ticketBusiness.GetById(request.IdTicket);
ticket.DataHoraAlteracao = DateTime.Now;
ticket.DataHoraUltimaMensagem = DateTime.Now;
//Se for uma mensagem interna enviada pelo suporte
if (request.UserType == "S" && request.Interno)
{
entity.IdAtendenteEmpresa = request.IdAutor;
ticket.IdStatusTicket = request.IdStatusTicket > 0 ? request.IdStatusTicket : 5; //Em Análise
}
else
{
//Se for uma mensagem enviada pelo suporte
if (request.UserType == "S" && !request.Interno)
{
entity.IdAtendenteEmpresa = request.IdAutor;
ticket.IdStatusTicket = request.IdStatusTicket > 0 ? request.IdStatusTicket : 4; //Pendente com Cliente
}
else
{
//Se for uma mensagem enviada pelo usuário cliente
if (request.UserType == "C")
{
entity.IdUsuarioCliente = request.IdAutor;
ticket.IdStatusTicket = 1; //Aguardando Atendimento
}
}
}
//Insere a nova mensagem
_ticketMensagemBusiness.Insert(ref entity);
if (entity.Id > 0)
{
//Atualiza o status do ticket, para refletir o novo momento do atendimento
_ticketBusiness.UpdateStatusTicket(ticket);
//Monta response
_result = Ok(Retorno <TicketMensagemResponse> .Criar(true, "Inclusão Realizada Com Sucesso", Mapper.Map <TicketMensagem, TicketMensagemResponse>(entity)));
if (Directory.Exists(pathAnexosUsuario))
{
//Zipa todos os anexos
var zipName = Arquivo.Compress(ConfigurationManager.AppSettings["CaminhoFisicoAnexo"], pathAnexosUsuario, entity.Id);
//======================================
//Guarda anexo (zip) no banco de dados
//======================================
var anexo = new Anexo
{
IdTicketMensagem = entity.Id,
Nome = zipName
};
_anexoBusiness.Insert(ref anexo);
}
//===========================================================================================
//Enviar email de confirmação de nova mensagem
//===========================================================================================
var ticketResponse = _ticketBusiness.GetByIdFilled(request.IdTicket, false);
if (request.UserType == "S")
{
usuarioCliente = _usuarioClienteBusiness.GetById(ticketResponse.UsuarioCliente.Id);
atendenteEmpresa = _atendenteEmpresaBusiness.GetById(request.IdAutor);
if (atendenteEmpresa.Copia)
{
listaAtendentes = _atendenteEmpresaBusiness.GetList(x => x.IdEmpresa == atendenteEmpresa.IdEmpresa && x.Id != atendenteEmpresa.Id).ToList();
}
}
else
{
usuarioCliente = _usuarioClienteBusiness.GetById(request.IdAutor);
listaAtendentes = _atendenteEmpresaBusiness.GetAll(ticketResponse.UsuarioCliente.Cliente.IdEmpresa).ToList();
}
try
{
_ticketMensagemBusiness.EnviarEmailConfirmacao(request, entity, ticketResponse, atendenteEmpresa, usuarioCliente, listaAtendentes);
}
catch (Exception)
{
//Monta response
_result = Ok(Retorno <TicketMensagemResponse> .Criar(true, "Inclusão Realizada Com Sucesso - Email de confirmação não enviado", Mapper.Map <TicketMensagem, TicketMensagemResponse>(entity)));
}
//===========================================================================================
}
//Retorna o response
return(_result);
}
catch (Exception)
{
throw new HttpResponseException(HttpStatusCode.InternalServerError);
}
}