public TarefaViewModel CarregarTela(string userId, long atividadeId)
{
var retorno = new TarefaViewModel
{
AnotacaoViewModal =
{
AnotacoesApoio = _anotacaoApoioServico.ObterAnotacoesApoio(null, atividadeId, null,
null, null)
},
StatusAtividade = _statusAtividadeServico.ObterTodos(),
TarefaAtividadeOcorrencia =
_tarefaAtividadeOcorrenciaServico.ObterTarefaAtividadeOcorrenciaApoio(atividadeId).FirstOrDefault()
};
retorno.TarefaAtividadeOcorrencia.CalcularTempo();
_tarefaServico.AtualizarDados(new Tarefa(retorno.TarefaAtividadeOcorrencia.tarefaID, userId,
retorno.TarefaAtividadeOcorrencia.AtividadeID));
retorno.AtividadeId = atividadeId;
var atividade = _atividadeServico.ObterPorId(atividadeId);
if (atividadeId > 0)
{
retorno.PodeEditar = string.IsNullOrEmpty(atividade.ResponsavelPorUserId)
? atividade.CriadoPorUserId == userId
: atividade.ResponsavelPorUserId == userId;
}
return(retorno);
}
public StatusAtendimentoViewModel Carregar(long atividadeId)
{
_statusAtendimentoViewModal.AtividadeId = atividadeId;
var atividade = _atividadeServico.ObterPorId(atividadeId);
_statusAtendimentoViewModal.StatusAtividade = _statusAtividadeServico.ObterStatusAtividadeTarefa();
_statusAtendimentoViewModal.Descricao =
_statusAtividadeServico.ObterPorId(atividade.StatusAtividadeId).Descricao;
return(_statusAtendimentoViewModal);
}
public AlterarResponsavelViewModel CarregarAlterarResponsavel(long?ocorrenciaId, long?atividadeId)
{
Usuario usuarioAtual;
if (ocorrenciaId.HasValue)
{
var ocorrencia = _ocorrenciaServico.ObterPorId((long)ocorrenciaId);
usuarioAtual = _usuarioServico.ObterPorUserId(ocorrencia.ResponsavelPorAspNetUserId);
}
else
{
var atividade = _atividadeServico.ObterPorId((long)atividadeId);
usuarioAtual = _usuarioServico.ObterPorUserId(atividade.ResponsavelPorUserId);
}
var listaUsuarios = _usuarioServico.ObterResponsaveisAtribuicao(ocorrenciaId, atividadeId);
if (usuarioAtual == null)
{
usuarioAtual = new Usuario();
}
return(new AlterarResponsavelViewModel(ocorrenciaId, atividadeId, usuarioAtual.Id, usuarioAtual.Nome,
new System.Web.Mvc.SelectList(listaUsuarios, "id", "nome")));
}
public AnotacaoFormViewModel CarregarAdicionarAnotacao(long?ocorrenciaId, long?atividadeId)
{
var retorno = new AnotacaoFormViewModel();
if (ocorrenciaId != null)
{
var ocorrencia = _servicoOcorrencia.ObterPorId((long)ocorrenciaId);
if (ocorrencia != null)
{
retorno.OcorrenciaId = ocorrencia.Id;
retorno.PessoaFisicaId = ocorrencia.PessoaFisicaId;
retorno.PessoaJuridicaId = ocorrencia.PessoaJuridicaId;
retorno.AnotacaoTipos =
new SelectList(_anotacaoTipoServico.ObterOcorrenciaTipoId(ocorrencia.OcorrenciasTiposId), "id",
"nome");
}
}
else if (atividadeId != null)
{
var atividade = _servicoAtividade.ObterPorId((long)atividadeId);
if (atividade != null)
{
retorno.OcorrenciaId = atividade.OcorrenciaId;
retorno.PessoaFisicaId = atividade.PessoasFisicasId;
retorno.PessoaJuridicaId = atividade.PessoasJuridicasId;
retorno.PotenciaisClienteId = atividade.PotenciaisClientesId;
retorno.AnotacaoTipos = new SelectList(_anotacaoTipoServico.ObterPadrao(), "id", "nome");
}
}
return(retorno);
}
public AtividadeViewModel SalvarAtendimentoLigacao(AtividadeViewModel view)
{
var entidade = _atividadeServico.ObterPorId(view.id);
entidade.PrevisaoDeExecucao = view.previsaoDeExecucao;
entidade.Descricao = view.descricao;
entidade.Titulo = view.titulo ?? "";
_atividadeServico.Atualizar(entidade);
entidade = _atividadeServico.ObterPorId(view.id);
if (view.filaID != null)
{
_atividadeServico.AtualizarResponsavel(entidade.Id, null, null);
var listaAtividadeFila =
_atividadeFilaServico.ObterPorAtividadeId(entidade.Id).Where(c => c.SaiuDaFilaEm == null);
foreach (var item in listaAtividadeFila)
{
_atividadeFilaServico.AtualizaSaiuDaFilaEm(item.Id);
}
_atividadeFilaServico.Adicionar(new AtividadeFila(entidade.Id, Convert.ToInt32(view.filaID)));
}
var ligacao = _ligacaoServico.ObterPorId(view.LigacaoViewModel.id);
ligacao.PessoaFisicaId = view.LigacaoViewModel.pessoaFisicaID;
ligacao.PessoaJuridicaId = view.LigacaoViewModel.pessoaJuridicaID == 0
? null
: view.LigacaoViewModel.pessoaJuridicaID;
ligacao.TelefoneId = view.LigacaoViewModel.telefoneID;
ligacao.Sentido = view.LigacaoViewModel.sentido;
var retornoLigacao = _ligacaoServico.Atualizar(ligacao);
return(new AtividadeViewModel(entidade.Id, entidade.AtividadeTipoId, view.LigacaoViewModel.pessoaFisicaID,
view.LigacaoViewModel.pessoaJuridicaID));
}
public ChatViewModel AdicionarAtendimento(string userId, string k)
{
var viewModel = new ChatViewModel();
var statusAtividade = _statusAtividadeServico.ObterStatusAtividadeChat();
var tipoAtividade = _atividadeTipoServico.BuscarPorNome("Chat");
var canal = _canalServico.ObterPorNome("chat");
var atividade = new Atividade();
if (!string.IsNullOrEmpty(k))
{
atividade = _atividadeServico.ObterPorId(Convert.ToInt64(k));
}
if (atividade.AtendimentoId != null)
{
var retornoAtendimento = _atendimentoServico.ObterPorId(atividade.AtendimentoId.Value);
retornoAtendimento.CanalOrigemId = 4;
_atendimentoServico.Atualizar(retornoAtendimento);
if (statusAtividade.Any() && tipoAtividade != null)
{
if (atividade.Id > 0)
{
atividade.AtendimentoId = retornoAtendimento.Id;
_atividadeServico.Atualizar(atividade);
}
IEnumerable <Cliente> listaCliente = new List <Cliente>();
if (atividade.PessoasJuridicasId.HasValue)
{
var pj = _pessoaJuridicaServico.ObterPorId(atividade.PessoasJuridicasId.Value);
if (pj != null)
{
atividade.PessoasJuridicasId = pj.Id;
_atividadeServico.Atualizar(atividade);
listaCliente = _clienteServico.ObterSugestoes(pj.NomeFantasia, pj.Cnpj, null, null);
viewModel.Popular(statusAtividade, retornoAtendimento.Protocolo, listaCliente,
retornoAtendimento.Id, null,
atividade.PessoasJuridicasId.Value, pj.NomeFantasia);
}
}
if (atividade.PessoasFisicasId.HasValue)
{
var pf = _pessoaFisicaServico.ObterPorId(atividade.PessoasFisicasId.Value);
if (pf != null)
{
atividade.PessoasFisicasId = pf.Id;
_atividadeServico.Atualizar(atividade);
listaCliente = _clienteServico.ObterSugestoes(pf.Nome, pf.Cpf, null, null);
viewModel.Popular(statusAtividade, retornoAtendimento.Protocolo, listaCliente,
retornoAtendimento.Id,
atividade.PessoasFisicasId.Value, null, pf.Nome);
}
}
else
{
viewModel.Popular(statusAtividade, retornoAtendimento.Protocolo, listaCliente,
retornoAtendimento.Id, null,
null, null);
}
}
else
{
viewModel.ValidationResult.Add(
new ValidationError("Não possui StatusAtividade Cadastrado."));
}
}
else if (statusAtividade.Any() && tipoAtividade != null)
{
var atendimento = new Atendimento(userId, _atendimentoServico.GerarNumeroProtocolo(DateTime.Now), null,
null);
var firstOrDefault = canal.FirstOrDefault();
if (firstOrDefault != null)
{
atendimento.CanalOrigemId = firstOrDefault.Id;
}
var atendimentoAux = _atendimentoServico.Adicionar(atendimento);
if (!atendimentoAux.IsValid)
{
return(viewModel);
}
if (atividade.Id > 0)
{
atividade.AtendimentoId = atendimento.Id;
_atividadeServico.Atualizar(atividade);
}
IEnumerable <Cliente> listaCliente = new List <Cliente>();
if (atividade.PessoasJuridicasId.HasValue)
{
var pj = _pessoaJuridicaServico.ObterPorId(atividade.PessoasJuridicasId.Value);
if (pj != null)
{
atividade.PessoasJuridicasId = pj.Id;
_atividadeServico.Atualizar(atividade);
listaCliente = _clienteServico.ObterSugestoes(pj.NomeFantasia, pj.Cnpj, null, null);
viewModel.Popular(statusAtividade, atendimento.Protocolo, listaCliente, atendimento.Id, null,
atividade.PessoasJuridicasId.Value, pj.NomeFantasia);
}
}
if (atividade.PessoasFisicasId.HasValue)
{
var pf = _pessoaFisicaServico.ObterPorId(atividade.PessoasFisicasId.Value);
if (pf != null)
{
atividade.PessoasFisicasId = pf.Id;
_atividadeServico.Atualizar(atividade);
listaCliente = _clienteServico.ObterSugestoes(pf.Nome, pf.Cpf, null, null);
viewModel.Popular(statusAtividade, atendimento.Protocolo, listaCliente, atendimento.Id,
atividade.PessoasFisicasId.Value, null, pf.Nome);
}
}
else
{
viewModel.Popular(statusAtividade, atendimento.Protocolo, listaCliente, atendimento.Id, null,
null, null);
}
}
else
{
viewModel.ValidationResult.Add(
new ValidationError("Não possui StatusAtividade Cadastrado."));
}
return(viewModel);
}
public ClienteBuscaViewModel AtualizarClienteAtividade(long atividadeId, long novoClienteId,
string novoClienteTipo, string userId, bool clienteSomenteContato, long?atualClienteId,
string atualClienteTipo, long?clienteTipoContato)
{
var retorno = new ClienteBuscaViewModel();
long?pessoaFisicaId = null;
long?pessoaJuridicaId = null;
long?atualPessoaFisicaId = null;
long?atualPessoaJuridicaId = null;
if (string.IsNullOrEmpty(novoClienteTipo))
{
retorno.ValidationResult.Add(
new DomainValidation.Validation.ValidationError(
"O tipo (pf= pessoa física / pj= pessoa jurídica) não foi informado."));
return(retorno);
}
if (atualClienteId.HasValue)
{
if (string.IsNullOrEmpty(atualClienteTipo))
{
retorno.ValidationResult.Add(
new DomainValidation.Validation.ValidationError(
"O tipo (pf= pessoa física / pj= pessoa jurídica) do cliente atual não foi informado."));
return(retorno);
}
if (atualClienteTipo.ToUpper().Trim() == "PF")
{
atualPessoaFisicaId = atualClienteId;
}
else if (atualClienteTipo.ToUpper().Trim() == "PJ")
{
atualPessoaJuridicaId = atualClienteId;
}
else
{
retorno.ValidationResult.Add(
new DomainValidation.Validation.ValidationError(
"O tipo informado do cliente atual não corresponde com os valores esperados: (pf= pessoa física / pj= pessoa jurídica)"));
return(retorno);
}
}
if (novoClienteTipo.ToUpper().Trim() == "PF")
{
pessoaFisicaId = novoClienteId;
}
else if (novoClienteTipo.ToUpper().Trim() == "PJ")
{
pessoaJuridicaId = novoClienteId;
}
else
{
retorno.ValidationResult.Add(
new DomainValidation.Validation.ValidationError(
"O tipo informado não corresponde com os valores esperados: (pf= pessoa física / pj= pessoa jurídica)"));
return(retorno);
}
// Aqui vou deletar o cliente atual do ParteEnvolvidas
if (atualPessoaFisicaId.HasValue || atualPessoaJuridicaId.HasValue)
{
_servicoAtividadeParteEnvolvidaServico.Excluir(atividadeId, atualPessoaFisicaId, atualPessoaJuridicaId);
}
var atividade = _servicoAtividade.ObterPorId(atividadeId);
if (atividade.AtividadeTipoId == 6)
{
var atividadeParteEnvolvidaCliente =
_servicoAtividadeParteEnvolvidaServico.ObterPorAtividadeId(atividadeId);
foreach (var parteEnvolvidada in atividadeParteEnvolvidaCliente)
{
if (parteEnvolvidada.TipoParteEnvolvida.ToLower().Trim() == "r")
{
parteEnvolvidada.SetarPessoaFisicaId(pessoaFisicaId);
parteEnvolvidada.SetarPessoaJuridicaId(pessoaJuridicaId);
_servicoAtividadeParteEnvolvidaServico.Atualizar(parteEnvolvidada);
}
}
_servicoAtividade.AtualizarCliente(atividadeId, pessoaFisicaId, pessoaJuridicaId, userId,
TipoParteEnvolvida.ClienteTratado.Value, false);
}
else
{
if (_servicoAtividadeParteEnvolvidaServico.PossuiClienteContato(atividadeId))
{
_servicoAtividadeParteEnvolvidaServico.Adicionar(new AtividadeParteEnvolvida(atividadeId,
pessoaFisicaId,
pessoaJuridicaId, null, userId, TipoParteEnvolvida.ClienteTratado.Value, null, null));
}
else
{
if (clienteSomenteContato)
{
_servicoAtividade.AtualizarCliente(atividadeId, pessoaFisicaId, pessoaJuridicaId, userId,
TipoParteEnvolvida.ClienteContato.Value);
if (atividade != null)
{
if (atividade.AtendimentoId.HasValue)
{
_servicoAtendimento.AtualizarClienteSomenteContato((long)atividade.AtendimentoId, true,
clienteTipoContato);
}
}
}
else
{
_servicoAtividade.AtualizarCliente(atividadeId, pessoaFisicaId, pessoaJuridicaId, userId,
TipoParteEnvolvida.ClienteTratado.Value);
}
}
}
retorno.PessoaJuridicaId = pessoaJuridicaId;
retorno.PessoaFisicaId = pessoaFisicaId;
retorno.AtividadeId = atividadeId;
return(retorno);
}
public ValidationResult AtualizarStatusAtividade(long ligacaoId, int statusAtividadeId, long atendimentoId,
long atividadeId,
string userId, int midiaId)
{
var retorno = new ValidationResult();
var statusAtividade = _servicoStatusAtividade.ObterPorId(statusAtividadeId);
if (!string.IsNullOrEmpty(statusAtividade.EntidadeNecessaria))
{
var podeAtualizar = _servicoStatusAtividade.VerificarEntidadeRequeridaAtendimento(atendimentoId,
statusAtividadeId);
if (!podeAtualizar)
{
retorno.Add(
new ValidationError(
string.Format(
"Não é possível alterar o status desse atendimento, pois ainda não houve criação e/ou interação de uma: {0}",
statusAtividade.EntidadeNecessaria)));
return(retorno);
}
}
if (!string.IsNullOrEmpty(statusAtividade.EntidadeNaoNecessaria))
{
var podeAtualizar = _servicoStatusAtividade.VerificarEntidadeNaoRequeridaAtendimento(atendimentoId,
statusAtividadeId);
if (!podeAtualizar)
{
retorno.Add(
new ValidationError(
string.Format(
"Não é possível alterar o status desse atendimento, pois houve criação e/ou interação de uma: {0}",
statusAtividade.EntidadeNaoNecessaria)));
return(retorno);
}
}
var ligacao = _servicoLigacao.ObterPorId(ligacaoId);
if (ligacao == null)
{
retorno.Add(
new ValidationError(
string.Format(
"Não foi possível alterar o status desse atendimento, nenhuma Ligação retornada com o Id: {0}",
ligacaoId)));
return(retorno);
}
atividadeId = ligacao.AtividadeId;
var atividade = _servicoAtividade.ObterPorId(atividadeId);
if (atividade == null)
{
retorno.Add(
new ValidationError(
string.Format(
"Não foi possível alterar o status desse atendimento, nenhuma Atividade retornada com o Id: {0}",
atividadeId)));
return(retorno);
}
_servicoAtividade.Atualizar(atividade, statusAtividade, userId, midiaId);
var atendimento = _servicoAtendimento.ObterPorId(atendimentoId);
if (atendimento != null)
{
if (statusAtividade.FinalizaAtendimento)
{
atendimento.FinalizadoEm = DateTime.Now;
atendimento.FinalizadoPorUserId = userId;
}
atendimento.MidiasId = midiaId;
_servicoAtendimento.Atualizar(atendimento);
}
ligacao.FinalizadoEm = DateTime.Now;
_servicoLigacao.Atualizar(ligacao);
return(retorno);
}