public ActionResult Atualizar(int?id)
{
if (id == null)
{
return(RedirectToAction(nameof(Index)));
}
var modelo = _modeloRepositorio.ObterModeloPorId(id.Value);
if (modelo == null)
{
RegistroNaoEncontrado();
}
var viewModel = new ModeloViewModel
{
Id = modelo.Id,
Descricao = modelo.Descricao,
DiasFreeTime = modelo.DiasFreeTime,
QtdeDias = modelo.QtdeDias,
Status = modelo.Status,
TipoOperacao = modelo.TipoOperacao,
Validade = modelo.Validade,
TipoValidade = modelo.TipoValidade,
FormaPagamento = modelo.FormaPagamento,
ImpostoId = modelo.ImpostoId,
VendedorId = modelo.VendedorId,
Acordo = modelo.Acordo,
Escalonado = modelo.Escalonado,
ParametroBL = modelo.ParametroBL,
ParametroLote = modelo.ParametroLote,
ParametroIdTabela = modelo.ParametroIdTabela,
ParametroConteiner = modelo.ParametroConteiner,
HubPort = modelo.HubPort,
CobrancaEspecial = modelo.CobrancaEspecial,
DesovaParcial = modelo.DesovaParcial,
FatorCP = modelo.FatorCP,
PosicIsento = modelo.PosicIsento,
TipoServico = modelo.TipoServico,
IntegraChronos = modelo.IntegraChronos,
Simular = modelo.Simular
};
PopularVendedores(viewModel);
PopularImpostos(viewModel);
PopularModelosSimulador(viewModel);
PopularVinculosModelosSimulador(viewModel);
return(View(viewModel));
}
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 EnviarAdendoParaAprovacao(int id)
{
var adendoBusca = _oportunidadeRepositorio.ObterAdendoPorId(id);
if (adendoBusca == null)
{
_logger.Info($"Adendo {adendoBusca.Id} não encontrado");
}
var oportunidadeBusca = _oportunidadeRepositorio.ObterOportunidadePorId(adendoBusca.OportunidadeId);
if (oportunidadeBusca == null)
{
_logger.Info($"Oportunidade {oportunidadeBusca.Id} não encontrada");
}
if (oportunidadeBusca.OportunidadeProposta == null || oportunidadeBusca.OportunidadeProposta.ModeloId == 0)
{
_logger.Info($"A Oportunidade {oportunidadeBusca.Id} não possui nenhum Modelo Vinculado");
}
var modelo = _modeloRepositorio.ObterModeloPorId(oportunidadeBusca.OportunidadeProposta.ModeloId);
var aprovacoes = _workflowRepositorio.ObterAprovacoesPorOportunidade(oportunidadeBusca.Id, Processo.ADENDO);
if (aprovacoes.Any() && adendoBusca.StatusAdendo == StatusAdendo.ENVIADO)
{
_logger.Info($"Já existe uma aprovação pendente para este Adendo {adendoBusca.Id}");
}
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);
IEnumerable <dynamic> clientes = null;
if (adendoBusca.TipoAdendo == TipoAdendo.INCLUSAO_SUB_CLIENTE)
{
clientes = _oportunidadeRepositorio
.ObterAdendoSubClientesInclusao(adendoBusca.Id)
.Select(c => $"{c.Descricao} ({ c.Documento})");
}
if (adendoBusca.TipoAdendo == TipoAdendo.INCLUSAO_GRUPO_CNPJ)
{
clientes = _oportunidadeRepositorio
.ObterAdendoGruposCNPJ(adendoBusca.Id, AdendoAcao.INCLUSAO)
.Select(c => $"{c.Descricao} ({ c.Documento})");
}
if (adendoBusca.TipoAdendo == TipoAdendo.EXCLUSAO_SUB_CLIENTE)
{
clientes = _oportunidadeRepositorio
.ObterAdendoSubClientesExclusao(adendoBusca.Id)
.Select(c => $"{c.Descricao} ({ c.Documento})");
}
if (adendoBusca.TipoAdendo == TipoAdendo.EXCLUSAO_GRUPO_CNPJ)
{
clientes = _oportunidadeRepositorio
.ObterAdendoGruposCNPJ(adendoBusca.Id, AdendoAcao.EXCLUSAO)
.Select(c => $"{c.Descricao} ({ c.Documento})");
}
if (adendoBusca.TipoAdendo == TipoAdendo.FORMA_PAGAMENTO)
{
var adendoFormaPagamento = _oportunidadeRepositorio
.ObterAdendoFormaPagamento(adendoBusca.Id)
.FormaPagamento
.ToName();
var lst = new List <string>
{
adendoFormaPagamento
};
clientes = lst;
}
if (adendoBusca.TipoAdendo == TipoAdendo.ALTERACAO_VENDEDOR)
{
var adendoVendedor = _oportunidadeRepositorio
.ObterAdendoVendedor(adendoBusca.Id).VendedorId;
var vendedor = _vendedorRepositorio.ObterVendedorPorId(adendoVendedor);
var lst = new List <string>
{
vendedor.Nome
};
clientes = lst;
}
var oportunidadeDetalhes = _oportunidadeRepositorio.ObterDetalhesOportunidade(oportunidadeBusca.Id);
var campos = new
{
OportunidadeId = oportunidadeBusca.Id,
Descricao = $"A-{adendoBusca.Id}",
DescricaoOportunidade = oportunidadeBusca.Descricao,
oportunidadeDetalhes.Conta,
oportunidadeDetalhes.TabelaId,
TipoAdendo = adendoBusca.TipoAdendo.ToName(),
StatusAdendo = adendoBusca.StatusAdendo.ToName(),
adendoBusca.DataCadastro,
adendoBusca.CriadoPor,
TipoOperacao = modelo.TipoOperacao.ToString(),
Clientes = clientes != null?string.Join(",", clientes) : string.Empty
};
var retorno = workflow.EnviarParaAprovacao(
new CadastroWorkflow(Processo.ADENDO, 1, adendoBusca.Id, User.ObterLogin(), User.ObterNome(), User.ObterEmail(), JsonConvert.SerializeObject(campos)));
if (retorno == null)
{
throw new Exception("Nenhuma resposta do serviço de Workflow");
}
if (retorno.sucesso == false)
{
_logger.Info(retorno.mensagem);
}
_workflowRepositorio.IncluirEnvioAprovacao(new EnvioWorkflow(oportunidadeBusca.Id, Processo.ADENDO, retorno.protocolo, retorno.mensagem, User.ObterId()));
_oportunidadeRepositorio.AtualizarStatusAdendo(StatusAdendo.ENVIADO, adendoBusca.Id);
_logger.Info($"Adendo {adendoBusca.Id} enviado para Aprovação");
}