public void Calcular(int oportunidadeId)
{
var oportunidade = _oportunidadeRepositorio.ObterOportunidadePorId(oportunidadeId);
if (oportunidade == null)
{
throw new Exception("Oportunidade não encontrada");
}
_simuladorRepositorio.LimparServicosSimulador(oportunidade.Identificacao);
var clientes = _simuladorRepositorio.ObterClientesSimulador(oportunidade.Identificacao);
_simuladorRepositorio.CadastrarTabela(
new SimuladorDTO
{
Proposta = oportunidade.Identificacao,
Descricao = oportunidade.Descricao,
Importador = clientes.Importador,
Despachante = clientes.Despachante,
Coloader = clientes.Coloader,
CoColoader = clientes.CoColoader,
CoColoader2 = clientes.CoColoader2
});
_simuladorRepositorio.ImportarArmazenagem(oportunidade.Identificacao, oportunidade.Id);
_simuladorRepositorio.ImportarServicoMargem(oportunidade.Identificacao, oportunidade.Id);
_simuladorRepositorio.ImportarServicoHubPort(oportunidade.Identificacao, oportunidade.Id);
_simuladorRepositorio.ImportarServicoMecanicaManual(oportunidade.Identificacao, oportunidade.Id);
_simuladorRepositorio.ImportarServicosGerais(oportunidade.Identificacao, oportunidade.Id);
_simuladorRepositorio.ImportarServicoLiberacao(oportunidade.Identificacao, oportunidade.Id);
}
public ActionResult Index(int modeloId, int oportunidadeId)
{
if (modeloId == 0)
{
return(RedirectToAction("Index", "Home"));
}
var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(oportunidadeId);
if (oportunidadeBusca == null)
{
return(RedirectToAction("Index", "Home"));
}
var servicos = _impostosExcecaoRepositorio.ObterServicos(modeloId, oportunidadeId);
return(View(new ImpostosExcecaoViewModel
{
ModeloId = modeloId,
OportunidadeId = oportunidadeId,
Tipo = TiposExcecoesImpostos.ImpostoAIsentar,
StatusOportunidade = oportunidadeBusca.StatusOportunidade,
Servicos = servicos
}));
}
public ActionResult EquipeUsuarios(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var oportunidade = _oportunidadeRepositorio.ObterOportunidadePorId(id.Value);
if (oportunidade == null)
{
RegistroNaoEncontrado();
}
var vendedor = _vendedorRepositorio.ObterVendedorPorId(oportunidade.OportunidadeProposta.VendedorId);
var viewModel = new EquipeOportunidadeViewModel
{
OportunidadeId = oportunidade.Id,
Proposta = oportunidade.Identificacao,
Descricao = oportunidade.Descricao,
StatusOportunidade = oportunidade.StatusOportunidade.ToName(),
Vendedor = vendedor?.Nome
};
var vinculos = _equipeOportunidadeRepositorio.ObterUsuariosVinculados(oportunidade.Id);
viewModel.Vinculos = vinculos;
return(View(viewModel));
}
public ActionResult CadastrarParametrosSimulador([Bind(Include = "SimuladorPropostaId, SimuladorPropostaModeloId, SimuladorPropostaOportunidadeId, SimuladorPropostaRegime, SimuladorPropostaPeriodos, SimuladorPropostaGrupoAtracacaoId, SimuladorPropostaTipoDocumentoId, SimuladorPropostaNumeroLotes, SimuladorPropostaMargem, SimuladorPropostaPeso, SimuladorPropostaVolumeM3, SimuladorPropostaArmadorId, SimuladorPropostaQtde20, SimuladorPropostaQtde40, SimuladorPropostaCif, Observacoes")] SimuladorPropostaViewModel viewModel)
{
var oportunidadeBusca = _oportunidadeRepositorio
.ObterOportunidadePorId(viewModel.SimuladorPropostaOportunidadeId);
if (oportunidadeBusca == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Oportunidade não encontrada"));
}
var parametro = new SimuladorPropostaParametros(
viewModel.SimuladorPropostaOportunidadeId,
viewModel.SimuladorPropostaModeloId,
oportunidadeBusca.TipoServico.ToName(),
viewModel.SimuladorPropostaMargem,
viewModel.SimuladorPropostaGrupoAtracacaoId,
viewModel.SimuladorPropostaVolumeM3,
viewModel.SimuladorPropostaPeso,
viewModel.SimuladorPropostaPeriodos,
viewModel.SimuladorPropostaTipoDocumentoId,
viewModel.SimuladorPropostaQtde20,
viewModel.SimuladorPropostaQtde40,
viewModel.Observacoes,
viewModel.SimuladorPropostaCif,
User.ObterId());
if (Enum.IsDefined(typeof(StatusOportunidade), oportunidadeBusca.StatusOportunidade))
{
if (oportunidadeBusca.StatusOportunidade != StatusOportunidade.RECUSADO)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, $"Não permitido para Oportunidades com Status {oportunidadeBusca.StatusOportunidade.ToName()}"));
}
}
if (viewModel.SimuladorPropostaModeloId == 0)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, $"Informe o Modelo do Simulador"));
}
var existe = _simuladorRepositorio
.ObterParametrosSimulador(viewModel.SimuladorPropostaOportunidadeId)
.FirstOrDefault(c => c.ModeloId == viewModel.SimuladorPropostaModeloId);
if (existe != null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Modelo de Simulador já cadastrado"));
}
_simuladorRepositorio.CadastrarParametrosSimulador(parametro);
var simuladores = _simuladorRepositorio.ObterParametrosSimulador(viewModel.SimuladorPropostaOportunidadeId).ToList();
return(PartialView("_ConsultaParametros", simuladores));
}
public override void OnActionExecuted(ActionExecutedContext context)
{
if (context.HttpContext.User.IsInRole("UsuarioExterno"))
{
if (context.RouteData != null && context.RouteData.Values["id"] == null)
{
return;
}
var oportunidadeId = context.RouteData.Values["id"].ToString().ToInt();
var oportunidade = oportunidadeRepositorio.ObterOportunidadePorId(oportunidadeId);
if (oportunidade != null)
{
if (!_usuarioRepositorio.ExisteVinculoConta(oportunidade.ContaId, HttpContext.Current.User.ObterId()))
{
context.Result = new RedirectResult("~/Home/AcessoNegado");
}
}
}
}
public override void OnActionExecuted(ActionExecutedContext context)
{
if (context.HttpContext.User.IsInRole("Administrador"))
{
return;
}
if (context.RouteData != null && context.RouteData.Values["id"] == null)
{
return;
}
var oportunidadeId = context.RouteData.Values["id"].ToString().ToInt();
var oportunidadeBusca = _oportunidadeRepositorio
.ObterOportunidadePorId(oportunidadeId);
if (oportunidadeBusca == null)
{
context.Result = new RedirectResult("~/Home/Indisponivel");
return;
}
var contaBusca = _contaRepositorio.ObterContaPorId(oportunidadeBusca.ContaId);
if (contaBusca == null)
{
return;
}
var login = HttpContext.Current.User.Identity.Name;
var vendedor = oportunidadeBusca.OportunidadeProposta.VendedorId == 0
? contaBusca.VendedorId
: oportunidadeBusca.OportunidadeProposta.VendedorId;
var permissoesPorVendedor = _equipeContaRepositorio
.ObterPermissoesOportunidadePorVendedor(vendedor, login);
var usuarioBusca = _usuarioRepositorio.ObterUsuarioPorId(HttpContext.Current.User.ObterId());
// Usuário esta vinculado a equipe do vendedor da oportunidade?
if (permissoesPorVendedor != null || usuarioBusca.Vendedor)
{
if (!usuarioBusca.Vendedor)
{
context.Controller.ViewBag.OportunidadeSomenteLeitura = permissoesPorVendedor.AcessoOportunidade == 0;
}
else
{
context.Controller.ViewBag.OportunidadeSomenteLeitura = false;
}
}
else
{
// Usuário esta vinculado a equipe da conta relacionada à oportunidade?
var permissoesPorConta = _equipeContaRepositorio
.ObterPermissoesContaPorConta(oportunidadeBusca.ContaId, login);
if (permissoesPorConta != null)
{
context.Controller.ViewBag.OportunidadeSomenteLeitura = permissoesPorConta.AcessoOportunidade == 0;
}
else
{
// Usuário esta vinculado a equipe da oportunidade?
var permissoesPorOportunidade = _equipeContaRepositorio.ObterPermissoesPorOportunidade(oportunidadeBusca.Id, login);
if (permissoesPorOportunidade != null)
{
context.Controller.ViewBag.OportunidadeSomenteLeitura = permissoesPorOportunidade.AcessoOportunidade == 0;
}
else
{
if (contaBusca == null)
{
context.Controller.ViewBag.OportunidadeSomenteLeitura = null;
}
else
{
context.Controller.ViewBag.OportunidadeSomenteLeitura = true;
}
}
}
}
}
public ActionResult Index(string termo, string chave, string menu)
{
if (!string.IsNullOrWhiteSpace(termo))
{
var contas = _contaRepositorio.ObterContasPorDescricao(termo, (int?)ViewBag.UsuarioExternoId);
var contatos = _contatoRepositorio.ObterContatosPorDescricao(termo, (int?)ViewBag.UsuarioExternoId);
var mercadorias = _mercadoriaRepositorio.ObterMercadoriaPorDescricao(termo);
var modelos = _modeloRepositorio.ObterModelosPorDescricao(termo);
var oportunidades = _oportunidadeRepositorio.ObterOportunidadesPorDescricao(termo, (int?)ViewBag.UsuarioExternoId);
var subClientes = _oportunidadeRepositorio.ObterSubClientesPorDescricao(termo, (int?)ViewBag.UsuarioExternoId);
var clientesGrupo = _oportunidadeRepositorio.ObterClientesGrupoCNPJPorDescricao(termo, (int?)ViewBag.UsuarioExternoId);
var adendosSubClientes = _oportunidadeRepositorio.ObterAdendosPorSubClientes(termo, (int?)ViewBag.UsuarioExternoId);
var servicos = _servicoRepositorio.ObterServicosPorDescricao(termo);
return(View(new BuscaViewModel
{
Termo = termo,
Contas = contas.ToList(),
Contatos = contatos.ToList(),
Mercadorias = mercadorias.ToList(),
Modelos = modelos.ToList(),
Oportunidades = oportunidades.ToList(),
SubClientes = subClientes.ToList(),
ClientesGrupoCNPJ = clientesGrupo.ToList(),
Servicos = servicos.ToList(),
AdendosSubClientes = adendosSubClientes.ToList()
}));
}
if (!string.IsNullOrWhiteSpace(chave))
{
var id = chave.ToInt();
Conta conta = new Conta();
Contato contato = new Contato();
Mercadoria mercadoria = new Mercadoria();
Modelo modelo = new Modelo();
Servico servico = new Servico();
Oportunidade oportunidade = new Oportunidade();
List <OportunidadeDTO> oportunidades = new List <OportunidadeDTO>();
List <ClientePropostaDTO> subClientes = new List <ClientePropostaDTO>();
List <ClientePropostaDTO> clientesGrupo = new List <ClientePropostaDTO>();
List <OportunidadeAdendoClientesDTO> adendosSubClientes = new List <OportunidadeAdendoClientesDTO>();
var viewModel = new BuscaViewModel();
switch (menu)
{
case "Contas":
conta = _contaRepositorio.ObterContaPorId(id);
if (ViewBag.UsuarioExternoId != null)
{
if (!_usuarioRepositorio.ExisteVinculoConta(conta.Id, ViewBag.UsuarioExternoId))
{
break;
}
}
if (conta != null)
{
viewModel.Contas.Add(conta);
subClientes = _oportunidadeRepositorio.ObterSubClientesPorConta(conta.Id).ToList();
if (subClientes != null)
{
viewModel.SubClientes.AddRange(subClientes);
}
clientesGrupo = _oportunidadeRepositorio.ObterClientesGrupoCNPJPorConta(conta.Id).ToList();
if (clientesGrupo != null)
{
viewModel.ClientesGrupoCNPJ.AddRange(clientesGrupo);
}
oportunidades = _oportunidadeRepositorio.ObterOportunidadesPorConta(conta.Id).ToList();
if (oportunidades != null)
{
viewModel.Oportunidades.AddRange(oportunidades);
}
}
break;
case "Contatos":
contato = _contatoRepositorio.ObterContatoPorId(id);
if (contato != null)
{
viewModel.Contatos.Add(contato);
}
break;
case "Mercadorias":
mercadoria = _mercadoriaRepositorio.ObterMercadoriaPorId(id);
if (mercadoria != null)
{
viewModel.Mercadorias.Add(mercadoria);
}
break;
case "Modelos":
modelo = _modeloRepositorio.ObterModeloPorId(id);
if (modelo != null)
{
viewModel.Modelos.Add(modelo);
}
break;
case "Oportunidades":
oportunidade = _oportunidadeRepositorio.ObterOportunidadePorId(id);
if (ViewBag.UsuarioExternoId != null)
{
if (!_usuarioRepositorio.ExisteVinculoConta(oportunidade.ContaId, ViewBag.UsuarioExternoId))
{
break;
}
}
if (oportunidade != null)
{
viewModel.Oportunidades.Add(new OportunidadeDTO
{
Id = oportunidade.Id,
Identificacao = oportunidade.Identificacao,
Descricao = oportunidade.Descricao,
ContaDescricao = oportunidade.Conta.Descricao,
SucessoNegociacao = oportunidade.SucessoNegociacao,
StatusOportunidade = oportunidade.StatusOportunidade
});
}
break;
case "Serviços":
servico = _servicoRepositorio.ObterServicoPorId(id);
if (servico != null)
{
viewModel.Servicos.Add(servico);
}
break;
default:
break;
}
return(View(viewModel));
}
return(RedirectToAction("Index", "Home"));
}
public override void OnActionExecuted(ActionExecutedContext context)
{
var oportunidadeId = 0;
if (context.RouteData != null && context.RouteData.Values["id"] != null)
{
oportunidadeId = context.RouteData.Values["id"].ToString().ToInt();
}
else
{
if (context.HttpContext.Request.Headers["Referer"] != null)
{
var referer = context.HttpContext.Request.Headers["Referer"].Split('/');
oportunidadeId = referer[referer.Length - 1].ToInt();
}
}
var oportunidadeBusca = _oportunidadeRepositorio
.ObterOportunidadePorId(oportunidadeId);
if (oportunidadeBusca == null)
{
throw new Exception($"Oportunidade ({oportunidadeId}) não encontrada");
}
var usuarioIntegracao = _usuarioRepositorio
.ObterUsuariosIntegracao()
.Where(c => c.UsuarioId == HttpContext.Current.User.ObterId()).FirstOrDefault();
if (usuarioIntegracao == null)
{
context.Controller.ViewBag.HabilitaBotaoIntegracaoProposta = false;
}
else
{
var modeloBusca = _modeloRepositorio.ObterModeloPorId(oportunidadeBusca.OportunidadeProposta.ModeloId);
if (modeloBusca == null)
{
context.Controller.ViewBag.HabilitaBotaoIntegracaoProposta = false;
}
else
{
var permiteIntegracao = modeloBusca.IntegraChronos;
var usuarioHabilitadoIntegracaoProducao = usuarioIntegracao.AcessoProducao;
var oportunidadeEnviadaAprovacao = oportunidadeBusca.StatusOportunidade == StatusOportunidade.ENVIADO_PARA_APROVACAO;
if (HttpContext.Current.User.IsInRole("BaseDesenvolvimento"))
{
context.Controller.ViewBag.HabilitaBotaoIntegracaoProposta = permiteIntegracao && oportunidadeEnviadaAprovacao;
}
else
{
context.Controller.ViewBag.HabilitaBotaoIntegracaoProposta = permiteIntegracao && oportunidadeEnviadaAprovacao && usuarioHabilitadoIntegracaoProducao;
}
}
}
}
public void EnviarOportunidadeParaAprovacao(int id, string criadoPor)
{
var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(id);
if (oportunidadeBusca == null)
{
_logger.Info($"Oportunidade {oportunidadeBusca.Id} não encontrada");
}
var token = Autenticador.Autenticar();
if (token == null)
{
_logger.Info("Não foi possível se autenticar no serviço de Workflow");
}
var workflow = new WorkflowService(token);
var oportunidadeDetalhes = _oportunidadeRepositorio.ObterDetalhesOportunidade(id);
var usuario = _usuarioRepositorio.ObterUsuarioPorId(criadoPor.ToInt());
var campos = new
{
oportunidadeId = oportunidadeDetalhes.Id,
oportunidadeDetalhes.Descricao,
oportunidadeDetalhes.Identificacao,
ContaId = oportunidadeDetalhes.Conta,
ContatoId = oportunidadeDetalhes.Contato,
MercadoriaId = oportunidadeDetalhes.Mercadoria,
oportunidadeDetalhes.Aprovada,
oportunidadeDetalhes.DataFechamento,
oportunidadeDetalhes.TabelaId,
oportunidadeDetalhes.Probabilidade,
oportunidadeDetalhes.SucessoNegociacao,
oportunidadeDetalhes.ClassificacaoCliente,
oportunidadeDetalhes.Segmento,
oportunidadeDetalhes.EstagioNegociacao,
oportunidadeDetalhes.StatusOportunidade,
oportunidadeDetalhes.MotivoPerda,
oportunidadeDetalhes.TipoDeProposta,
oportunidadeDetalhes.TipoServico,
oportunidadeDetalhes.TipoNegocio,
oportunidadeDetalhes.TipoOperacaoOportunidade,
oportunidadeDetalhes.RevisaoId,
oportunidadeDetalhes.Observacao,
oportunidadeDetalhes.FaturamentoMensalLCL,
oportunidadeDetalhes.FaturamentoMensalFCL,
oportunidadeDetalhes.VolumeMensal,
oportunidadeDetalhes.CIFMedio,
oportunidadeDetalhes.PremioParceria,
CriadoPor = usuario.Login,
oportunidadeDetalhes.TipoOperacao,
oportunidadeDetalhes.Vendedor,
oportunidadeDetalhes.FormaPagamento,
DataInicio = oportunidadeDetalhes.DataInicio.DataFormatada(),
DataTermino = oportunidadeDetalhes.DataTermino.DataFormatada()
};
var retorno = workflow.EnviarParaAprovacao(
new CadastroWorkflow(Processo.OPORTUNIDADE, 1, oportunidadeBusca.Id, usuario.Login, usuario.Nome, usuario.Email, JsonConvert.SerializeObject(campos)));
if (retorno == null)
{
throw new Exception("Nenhuma resposta do serviço de Workflow");
}
if (retorno.sucesso == false)
{
_logger.Info(retorno.mensagem);
}
var oportunidadeWorkflow = new EnvioWorkflow(oportunidadeBusca.Id, Processo.OPORTUNIDADE, retorno.protocolo, retorno.mensagem, usuario.Id);
_workflowRepositorio.IncluirEnvioAprovacao(oportunidadeWorkflow);
if (oportunidadeBusca.StatusOportunidade != StatusOportunidade.CANCELADA)
{
oportunidadeBusca.StatusOportunidade = StatusOportunidade.ENVIADO_PARA_APROVACAO;
}
_oportunidadeRepositorio.AtualizarStatusOportunidade(oportunidadeBusca.StatusOportunidade, oportunidadeBusca.Id);
}
public bool ValidarEquipeOportunidade(int oportunidadeId)
{
if (HttpContext.Current.User.IsInRole("Administrador"))
{
return(true);
}
if (HttpContext.Current.User.IsInRole("UsuarioExterno"))
{
return(true);
}
var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(oportunidadeId);
if (oportunidadeBusca == null)
{
throw new Exception("Oportunidade não encontrada ou já excluída");
}
var login = HttpContext.Current.User.Identity.Name;
var permissoesPorVendedor = _equipeContaRepositorio
.ObterPermissoesOportunidadePorVendedor(oportunidadeBusca.OportunidadeProposta.VendedorId, login);
// Usuário esta vinculado a equipe do vendedor da oportunidade?
if (permissoesPorVendedor != null)
{
if (permissoesPorVendedor.AcessoOportunidade == 1)
{
return(true);
}
}
else
{
// Usuário esta vinculado a equipe da conta relacionada à oportunidade?
var permissoesPorConta = _equipeContaRepositorio
.ObterPermissoesContaPorConta(oportunidadeBusca.ContaId, login);
if (permissoesPorConta != null)
{
if (permissoesPorConta.AcessoOportunidade == 1)
{
return(true);
}
}
else
{
// Usuário esta vinculado a equipe da oportunidade?
var permissoesPorOportunidade = _equipeContaRepositorio.ObterPermissoesPorOportunidade(oportunidadeBusca.Id, login);
if (permissoesPorOportunidade != null)
{
if (permissoesPorOportunidade.AcessoOportunidade == 1)
{
return(true);
}
}
}
}
return(false);
}
public ActionResult RecallOportunidade(int recallOportunidadeId, string motivoRecallOportunidade)
{
var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(recallOportunidadeId);
if (oportunidadeBusca == null)
{
throw new Exception("Oportunidade não encontrada ou já excluída");
}
var token = Autenticador.Autenticar();
if (token == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Não foi possível se autenticar no serviço de Recall"));
}
var ultimoProtocolo = _workflowRepositorio.UltimoProtocolo(oportunidadeBusca.Id, Processo.OPORTUNIDADE);
var workflow = new RecallService(token);
var retorno = workflow.Recall(new CadastroRecall(ultimoProtocolo, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), motivoRecallOportunidade));
if (retorno == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, "Nenhuma resposta do serviço de Recall"));
}
if (retorno.sucesso)
{
if (oportunidadeBusca.Cancelado)
{
//_oportunidadeRepositorio.AtualizarStatusOportunidade(StatusOportunidade.ATIVA, oportunidadeBusca.Id);
//_oportunidadeRepositorio.AtualizarCancelamentoOportunidade(false, oportunidadeBusca.Id);
//_oportunidadeRepositorio.AtualizarDataCancelamentoOportunidade(null, oportunidadeBusca.Id);
_oportunidadeRepositorio.PermiteAlterarDataCancelamento(oportunidadeBusca.Id, true);
}
if (oportunidadeBusca.StatusOportunidade == StatusOportunidade.ENVIADO_PARA_APROVACAO)
{
_oportunidadeRepositorio.AtualizarStatusOportunidade(null, oportunidadeBusca.Id);
}
var fichasFaturamento = _oportunidadeRepositorio.ObterFichasFaturamento(oportunidadeBusca.Id);
foreach (var ficha in fichasFaturamento)
{
if (ficha.StatusFichaFaturamento == StatusFichaFaturamento.EM_APROVACAO)
{
_oportunidadeRepositorio.AtualizarStatusFichaFaturamento(StatusFichaFaturamento.EM_ANDAMENTO, ficha.Id);
}
}
return(Json(new
{
Processo = Processo.OPORTUNIDADE,
RedirectUrl = $"/Oportunidades/Atualizar/{oportunidadeBusca.Id}"
}, JsonRequestBehavior.AllowGet));
}
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest, retorno.mensagem));
}