/// <summary>
///
/// </summary>
/// <param name="oportunidade"></param>
/// <param name="token"></param>
/// <returns></returns>
/// <exception cref="OportunidadeException"></exception>
public async Task SaveAsync(Oportunidade oportunidade, string token)
{
try
{
if (oportunidade.ID == 0)
{
await _segService.ValidateTokenAsync(token);
oportunidade.DataCriacao = DateTime.UtcNow;
oportunidade.DataEdicao = DateTime.UtcNow;
oportunidade.Ativo = true;
var result = _opRepository.Add(oportunidade);
await _endService.SaveEnderecoAsync(oportunidade.Endereco, token);
}
else
{
await UpdateAsync(oportunidade, token);
}
}
catch (Exception e)
{
throw new OportunidadeException("Não foi possível salvar a oportunidade.", e);
}
}
public ListResponse Alterar(Oportunidade oportunidade)
{
var listResponse = new List <string>();
if (oportunidade.Titulo == "")
{
listResponse.Add("Título não preenchido.");
}
if (oportunidade.Empresa == "")
{
listResponse.Add("Empresa não preenchida.");
}
if (oportunidade.EstadoId == 0)
{
listResponse.Add("Estado não preenchido.");
}
if (oportunidade.CidadeId == 0)
{
listResponse.Add("Cidade não preenchida.");
}
if (oportunidade.Regime == "")
{
listResponse.Add("Regime de contratação não preechido.");
}
if (oportunidade.Posicao == "")
{
listResponse.Add("Posição não preenchida.");
}
if (oportunidade.JobDescription == "")
{
listResponse.Add("JobDescription não preenchido.");
}
if (listResponse.Count > 0)
{
return new ListResponse()
{
Mensagem = "Bad Request",
StatusCode = StatusCodes.Status400BadRequest,
Erros = listResponse
}
}
;
oportunidade.DataHoraCriacao = DateTime.Now;
_oportunidadeRepository.Alterar(oportunidade);
return(new ListResponse()
{
StatusCode = StatusCodes.Status202Accepted, Mensagem = "Oportunidade alterada com sucesso!"
});
}
public int CriarSimulador(ParametrosSimuladorCRM parametros, Oportunidade oportunidade)
{
var simulador = new Simulador
{
Descricao = "Simulador CRM"
};
if (parametros.Regime == Regime.LCL)
{
simulador.ValorCifCargaSolta = parametros.ValorCif;
simulador.Regime = "1"; //LCL
}
else
{
simulador.ValorCifConteiner = parametros.ValorCif;
simulador.Regime = "0"; //FCL
}
simulador.Periodos = parametros.Periodos;
simulador.TipoDocumento = parametros.DocumentoId;
simulador.VolumeM3 = parametros.VolumeM3;
simulador.NumeroLotes = parametros.NumeroLotes;
simulador.GrupoAtracacao = parametros.GrupoAtracacaoId;
simulador.Qtde20 = parametros.Qtde20;
simulador.Qtde40 = parametros.Qtde40;
simulador.CriadoPor = _usuarioId;
var simuladorId = _simuladorDAO.CadastrarSimulador(simulador);
return(simuladorId);
}
public int Incluir(Oportunidade oportunidade)
{
const string insert = @"
INSERT INTO [dbo].[Oportunidade]
([Titulo]
,[Empresa]
,[DataHoraCriacao]
,[EstadoId]
,[CidadeId]
,[Regiao]
,[Remuneracao]
,[Regime]
,[Posicao]
,[JobDescription]
,[Situacao])
output INSERTED.Id VALUES
(@Titulo
,@Empresa
,@DataHoraCriacao
,@EstadoId
,@CidadeId
,@Regiao
,@Remuneracao
,@Regime
,@Posicao
,@JobDescription
,@Situacao)
";
using (var con = new SqlConnection(ObterConexao))
{
con.Open();
return(con.ExecuteScalar <int>(insert, oportunidade));
}
}
public int Incluir(Oportunidade oportunidade)
{
string query = @"
INSERT INTO [dbo].[Oportunidade]
([Titulo]
,[Empresa]
,[DataHoraCriacao]
,[EstadoId]
,[CidadeId]
,[Regiao]
,[Remuneracao]
,[Regime]
,[Posicao]
,[JobDescription]
,[Situacao])
OUTPUT Inserted.Id
VALUES
(@Titulo
,@Empresa
,@DataHoraCriacao
,@EstadoId
,@CidadeId
,@Regiao
,@Remuneracao
,@Regime
,@Posicao
,@JobDescription
,@Situacao)
";
var con = new SqlConnection(_connectionString);
con.Open();
return(con.ExecuteScalar <int>(query, oportunidade));
}
public async Task <IActionResult> SaveAsync([FromRoute] string token, [FromBody] Oportunidade oportunidade)
{
try
{
var op = await _opDomain.SaveAsync(oportunidade, token);
op.Endereco = await _edDomain.SaveAsync(op.Endereco, token);
if (oportunidade.ID == 0)
{
await _emailHandler.EnviarEmailAsync(token, op);
}
return(Ok(op));
}
catch (InvalidTokenException e)
{
return(StatusCode(401, $"{ e.Message } { e.InnerException.Message }"));
}
catch (OportunidadeException e)
{
return(StatusCode(400, $"{ e.Message } { e.InnerException.Message }"));
}
catch (EnderecoException e)
{
return(StatusCode(400, $"{ e.Message } { e.InnerException.Message }"));
}
catch (Exception e)
{
return(StatusCode(500, "Ocorreu um erro ao tentar salvar a oportunidade recebida. Entre em contato com o suporte."));
}
}
private Oportunidade ManterDadosEssenciais(Oportunidade oportunidade, Oportunidade oportunidadeAtual)
{
oportunidade.DataExpiracao = oportunidadeAtual.DataExpiracao;
oportunidade.Comissao = oportunidadeAtual.Comissao;
oportunidade.DataCadastro = oportunidadeAtual.DataCadastro;
return(oportunidade);
}
public void AddOportunidade(Oportunidade item)
{
db.Oportunidade.Add(item);
db.SaveChanges();
var idOp = item.IdOportunidade;
}
private bool VerificaSeNaoEhMesmoVendedorAutenticado(Oportunidade oportunidade)
{
if (oportunidade.VendedorId != _user.GetUserId())
{
return(true);
}
return(false);
}
private bool VerificaSeStatusPossibilitaExclusao(Oportunidade oportunidade)
{
if (oportunidade.Status != EStatusOportunidade.Aceita)
{
return(true);
}
return(false);
}
private bool VerificaSeMarcadoComoExcluido(Oportunidade oportunidade)
{
if (oportunidade.Excluido)
{
return(true);
}
return(false);
}
public PropostaPdfHelper(IAnexoRepositorio anexoRepositorio, Oportunidade oportunidade, bool anexar = false, string url = "", bool externo = false)
{
_anexoRepositorio = anexoRepositorio;
_oportunidade = oportunidade;
_anexar = anexar;
_externo = externo;
_url = url;
}
private bool VerificaSeStatusPossibilitaAtualizacao(Oportunidade oportunidade)
{
if (oportunidade.Status == EStatusOportunidade.Criada)
{
return(true);
}
return(false);
}
private bool VerificaDataDeValidade(Oportunidade oportunidade)
{
if (oportunidade.DataExpiracao <= DateTime.Now)
{
return(true);
}
return(false);
}
public Oportunidade Salvar(string nome, string salário)
{
Oportunidade oportunidade = new Oportunidade();
oportunidade.Nome = nome;
oportunidade.Salario = salário;
return(oportunidade);
}
public Oportunidade AtribuirCandidatoAprovado(Oportunidade oportunidade, string nomeCandidato)
{
oportunidade.Candidatos.ForEach(c => {
if (c.Nome == nomeCandidato)
{
c.Aprovado = true;
}
});
return(oportunidade);
}
public static async Task <bool> SaveAsync(Oportunidade oportunidade, int idCliente, string token)
{
if (await SeguracaServ.validaTokenAsync(token))
{
if (oportunidade.ID == 0)
{
OportunidadeRep rep = new OportunidadeRep();
oportunidade.DataCriacao = DateTime.Now;
oportunidade.DataEdicao = DateTime.Now;
oportunidade.Ativo = true;
try
{
rep.Add(oportunidade);
if (await EnderecoServ.SaveEnderecoAsync(oportunidade.Endereco, token))
{
return(false);
}
return(false);
}
catch (Exception e)
{
///:)
return(false);
}
}
else
{
OportunidadeRep rep = new OportunidadeRep();
oportunidade.DataEdicao = DateTime.Now;
try
{
rep.Update(oportunidade);
if (await EnderecoServ.RemoveEnderecoAsync(oportunidade.Endereco, token))
{
await EnderecoServ.SaveEnderecoAsync(oportunidade.Endereco, token);
return(true);
}
return(false);
}
catch (Exception e)
{
///:)
return(false);
}
}
}
else
{
return(false);
}
}
public void DeleteAsync(Oportunidade oportunidade, string token)
{
try
{
_opRepository.Remove(oportunidade);
}
catch (Exception e)
{
throw new OportunidadeException("Não foi possível remover a oportunidade.", e);
}
}
private bool VerificaSeExisteVeiculoCadastradoDisponivel(Oportunidade oportunidade)
{
if (_veiculoRepository.Buscar(v =>
(v.Id == oportunidade.VeiculoId &&
(v.Status == EStatusVeiculo.Disponivel))).Result.Any())
{
return(false);
}
return(true);
}
private Oportunidade MontarOportunidade(Oportunidade oportunidade, Causa causa, Usuario instituicao, Endereco endereco)
{
instituicao.DefinirCausas(_repositorioUsuarioCausa.Consultar(instituicao.Id));
return(new OportunidadeBuilder()
.APartir(oportunidade)
.ComCausa(causa)
.ComInstituicao(instituicao)
.ComInstituicaoEndereco(endereco)
.ComCandidatos(_repositorioOportunidadeCandidatura.Consultar(oportunidade.Id))
.Construir());
}
public int?ObterRazaoStatusOportunidade(Oportunidade oportunidade)
{
int?razaostatus = 993520003;
if ((oportunidade.RazaoStatus == 1) || (oportunidade.RazaoStatus == 200011))
{
if (oportunidade.StageId != null)
{
if (oportunidade.StageId.Value.ToString().ToUpper() == "A5C2D354-2233-D85E-CE43-366685757134")
{
razaostatus = 993520001;
}
if ((oportunidade.StageId.Value.ToString().ToUpper() == "1DB22B78-19E7-5CA1-CCB1-BD84AE230087") || (oportunidade.StageId.Value.ToString().ToUpper() == "E2B91BCD-488A-5410-9049-1E7C8ADBE72C"))
{
razaostatus = 993520007;
}
if (oportunidade.StageId.Value.ToString().ToUpper() == "CDA64E48-BABC-4EBB-CE63-8D7DE2C9729D")
{
razaostatus = 993520008;
}
if (oportunidade.StageId.Value.ToString().ToUpper() == "08B6E87E-5D19-3952-64BC-D6C0EDE6DA37")
{
razaostatus = 993520009;
}
if (oportunidade.StageId.Value.ToString().ToUpper() == "6E7E126A-A9A0-6CDE-74AC-1509ABA87087")
{
razaostatus = 993520010;
}
}
else
{
razaostatus = 993520007;
}
}
else if (oportunidade.RazaoStatus == 3)
{
razaostatus = 993520001;
}
else if (oportunidade.RazaoStatus == 4)
{
razaostatus = 993520002;
}
else if (oportunidade.RazaoStatus == 5)
{
razaostatus = 993520000;
}
else
{
razaostatus = oportunidade.RazaoStatus;
}
return(razaostatus);
}
public void UpdateOportunidade(Oportunidade item)
{
var itemOportunidade = BuscarOportunidadeId(item.IdOportunidade);
itemOportunidade.IdSituacao = item.IdSituacao;
itemOportunidade.IdTipoOportunidade = item.IdTipoOportunidade;
itemOportunidade.DsAssunto = item.DsAssunto;
itemOportunidade.DsObservacao = item.DsObservacao;
itemOportunidade.DtLimiteEntregaProposta = item.DtLimiteEntregaProposta;
itemOportunidade.IdUsuarioUltimaAlteracao = AppSettings.constGlobalUserID;
db.SaveChanges();
}
private Oportunidade InserirDadosIniciais(Oportunidade oportunidade)
{
oportunidade.VendedorId = _user.GetUserId();
oportunidade.Status = EStatusOportunidade.Criada;
oportunidade.Excluido = false;
if (oportunidade.Id.Equals(Guid.Empty))
{
oportunidade.Id = Guid.NewGuid();
}
return(oportunidade);
}
public async Task <ActionResult <OportunidadeViewModel> > Adicionar(OportunidadeViewModel oportunidadeViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
Oportunidade oportunidade = await _oportunidadeService.Adicionar(_mapper.Map <Oportunidade>(oportunidadeViewModel));
oportunidadeViewModel = _mapper.Map <OportunidadeViewModel>(oportunidade);
return(CustomResponse(oportunidadeViewModel));
}
public OportunidadeBuilder APartir(Oportunidade oportunidade)
{
_oportunidade.Descricao = oportunidade.Descricao;
_oportunidade.Qualificacoes = oportunidade.Qualificacoes;
_oportunidade.Ativa = oportunidade.Ativa;
_oportunidade.Causa = oportunidade.Causa;
_oportunidade.Id = oportunidade.Id;
_oportunidade.QuantidadeVagas = oportunidade.QuantidadeVagas;
_oportunidade.DataAtualizacao = oportunidade.DataAtualizacao;
_oportunidade.DataCriacao = oportunidade.DataCriacao;
_oportunidade.Turno = oportunidade.Turno;
return(this);
}
public void Salvar()
{
Oportunidade op = new Oportunidade
{
Ativo = true,
//Bairro = "Higienopolis",
//CEP = "01244-010",
//Cidade = "São Paulo",
//Complemento = "Perto da band",
DataCriacao = DateTime.Now,
DataEdicao = DateTime.Now,
DataOportunidade = DateTime.Now,
Descricao = "Evento teste",
Endereco = new Endereco()
{
Ativo = true,
Bairro = "Higienopolis",
CEP = "01244-010",
Cidade = "São Paulo",
Complemento = "Perto da Band",
DataCriacao = DateTime.UtcNow,
DataEdicao = DateTime.UtcNow,
Descricao = "Endereço de teste",
Estado = "SP",
NumeroLocal = 32,
},
//Estado = "SP",
HoraFim = new TimeSpan(20, 20, 0),
HoraInicio = new TimeSpan(18, 0, 0),
Nome = "Evento 1",
//NumeroLocal = 32,
Quantidade = 10,
Status = 1,
TipoProfissional = 1,
UsuarioCriacao = 1,
UsuarioEdicao = 1,
Valor = 200.00m,
ID = 0,
TipoServico = 1
};
try
{
var t = SimpleJson.SimpleJson.SerializeObject(op);
OportunidadeBO.SaveAsync(op, 1, "");
}
catch (Exception E)
{
/////
}
}
private bool VerificaConsistenciaDaOportunidadeRecebida(Oportunidade oportunidade, Oportunidade oportunidadeAtual)
{
if (oportunidade.Id != oportunidadeAtual.Id)
{
return(true);
}
if (oportunidade.VeiculoId != oportunidadeAtual.VeiculoId)
{
return(true);
}
return(false);
}
public async Task EnviarEmailAsync(string token, Oportunidade oportunidade, UserXOportunidade userXOportunidade)
{
try
{
await _segService.ValidateTokenAsync(token);
var(emailConfigs, emailConstants) = GetConfiguration();
var content = await System.IO.File.ReadAllTextAsync("wwwroot/Match-Opt.html");
foreach (var item in emailConstants)
{
var text = string.Empty;
if ("endereco".Equals(item.Key.ToLower()))
{
text = oportunidade.Endereco.GetType().GetProperty("Descricao").GetValue(oportunidade.Endereco, null).ToString();
}
if ("nomecontratado".Equals(item.Key.ToLower()))
{
text = userXOportunidade.GetType().GetProperty("NomeContratado").GetValue(userXOportunidade, null).ToString();
}
else
{
text = oportunidade.GetType().GetProperty(item.Key).GetValue(oportunidade, null).ToString();
}
if (!string.IsNullOrEmpty(text))
{
content = content.Replace(item.Value, text);
}
}
var configuracoes = await _configService.GetConfiguracoesAsync(oportunidade.IdCliente, oportunidade.UsuarioCriacao);
var sender = emailConfigs.GetValue <string>("Sender");
var configuracao = configuracoes.Where(c => c.Chave.Equals(sender)).SingleOrDefault();
if (!string.IsNullOrEmpty(oportunidade.EmailEmpresa))
{
var emailToClient = new Email(content, $"Oportunidade: { oportunidade.Nome }", configuracao.Valor, oportunidade.EmailEmpresa, oportunidade.IdCliente);
await _emailService.EnviarEmailAsync(emailToClient, oportunidade.IdCliente, oportunidade.UsuarioCriacao);
}
}
catch (Exception e)
{
//Erro ao enviar e-mail não impacta no processo
}
}
public static RespostaErro CreateProposta(Oportunidade oportunidade)
{
Lib_Primavera.Model.RespostaErro erro = new Model.RespostaErro();
StdBELista props = PriEngine.Engine.Consulta(@"SELECT Count(*) AS N FROM PropostasOPV
WHERE IdOportunidade = '" + oportunidade.ID + "' ;");
int n = props.Valor("N");
//maximo 4 propostas
if (n >= 4)
{
erro.Erro = 1;
erro.Descricao = "The maximum of proposals is four.";
return(erro);
}
CrmBEPropostaOPV prop = new CrmBEPropostaOPV();
try
{
if (PriEngine.InitializeCompany(FirstREST.Properties.Settings.Default.Company.Trim(), FirstREST.Properties.Settings.Default.User.Trim(), FirstREST.Properties.Settings.Default.Password.Trim()) == true)
{
prop.set_IdOportunidade(oportunidade.ID);
prop.set_IdCabecOrigem(oportunidade.ID);
short x = (short)n;
x++;
prop.set_NumProposta(x);
prop.set_Valor(0);
//var opp = PriEngine.Engine.CRM.OportunidadesVenda.EditaID(oportunidade.ID);
PriEngine.Engine.CRM.PropostasOPV.Actualiza(prop);
erro.Erro = 0;
erro.Descricao = "Sucesso";
return(erro);
}
else
{
erro.Erro = 1;
erro.Descricao = "Erro ao abrir empresa";
return(erro);
}
}
catch (Exception ex)
{
erro.Erro = 1;
erro.Descricao = ex.Message;
return(erro);
}
}
public async Task <string> SaveAsync([FromBody] Oportunidade obj, int idCliente, string token)
{
OportunidadeBO oportunidade = new OportunidadeBO();
try
{
await OportunidadeBO.SaveAsync(obj, idCliente, token);
return("Oportunidade cadastrada com sucesso");
}
catch (Exception e)
{
return("Houve uma falha ao salvar, aguarde uns instante ou entre em contato com o suporte");
}
}
