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);
            }
        }
Ejemplo n.º 2
0
        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);
            }
        }
Ejemplo n.º 4
0
        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);
            }
        }
Ejemplo n.º 5
0
        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));
                }
            }
        }
Ejemplo n.º 6
0
        //[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);
            }
        }
Ejemplo n.º 7
0
        //[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);
            }
        }
Ejemplo n.º 9
0
        //[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);
            }
        }
Ejemplo n.º 10
0
        //[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);
            }
        }
Ejemplo n.º 13
0
        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);
            }
        }
Ejemplo n.º 14
0
        //[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);
            }
        }
Ejemplo n.º 16
0
        //[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);
            }
        }
Ejemplo n.º 17
0
        //[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);
            }
        }
Ejemplo n.º 19
0
        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));
                }
            }
        }
Ejemplo n.º 20
0
        //[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);
            }
        }
Ejemplo n.º 21
0
        //[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);
            }
        }
Ejemplo n.º 22
0
        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);
            }
        }