private decimal ObterValorAtingimento(IndicadorEntity indicadorEntity, decimal valorMeta, decimal valorRealizado)
{
decimal diferencaRealizadoMeta = valorRealizado - valorMeta;
decimal diferencaSobreMeta = diferencaRealizadoMeta / valorMeta;
decimal pesoSobreCriterio = indicadorEntity.ValorPercentualPeso / indicadorEntity.ValorPercentualCriterio;
decimal produto = diferencaSobreMeta * pesoSobreCriterio;
decimal atingimento = produto * 100;
if (indicadorEntity.TipoCardinalidade == TipoCardinalidade.QuantoMaiorMelhor)
{
atingimento = (1 + produto) * 100;
}
else if (indicadorEntity.TipoCardinalidade == TipoCardinalidade.QuantoMenorMelhor)
{
atingimento = (1 - produto) * 100;
}
if (indicadorEntity.ValorMinimoAtingimento.HasValue && atingimento < indicadorEntity.ValorMinimoAtingimento.Value)
{
return(indicadorEntity.ValorMinimoAtingimento.Value);
}
else if (indicadorEntity.ValorMaximoAtingimento.HasValue && atingimento > indicadorEntity.ValorMaximoAtingimento.Value)
{
return(indicadorEntity.ValorMaximoAtingimento.Value);
}
return(atingimento);
}
/// <summary>
/// Permite obtener una Observacion Planeada Entity
/// </summary>
/// <param name="CodigoExpediente"></param>
/// <returns>Entidad Observacion Planeada Response</returns>
public ProcessResult <IndicadorResponse> ObtenerIndicador(IndicadorRequest data)
{
ProcessResult <IndicadorResponse> resultado = new ProcessResult <IndicadorResponse>();
resultado.Result = new IndicadorResponse();
try
{
if (data.CodigoIndicador.HasValue)
{
IndicadorEntity IndicadorEntity = indicadorEntityRepository.GetById(data.CodigoIndicador);
if (IndicadorEntity != null)
{
ResponsableEntity responsableEntity = responsableEntityRepository.GetById(IndicadorEntity.CodigoResponsable);
resultado.Result = Mapper.Map <IndicadorEntity, IndicadorResponse>(IndicadorEntity);
resultado.Result.NombreCompletoResponsable = responsableEntity.Nombres + " " + responsableEntity.ApellidoPaterno + " " + responsableEntity.ApellidoMaterno;
resultado.Result.FechaInicioVigenciaString = resultado.Result.FechaInicioVigencia.Value.ToShortDateString();
resultado.Result.FechaFinVigenciaString = resultado.Result.FechaFinVigencia.Value.ToShortDateString();
}
}
}
catch (Exception ex)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <IndicadorService>(ex.Message);
}
return(resultado);
}
private decimal ObterValorCalculado(IndicadorEntity indicador, long idProjeto, DateTime dataInicial, DateTime dataFinal, bool meta = true)
{
if (indicador.Formula is null)
{
throw new ArgumentNullException($"A fórmuala do indicador: '{indicador.Identificador}' não foi definida.");
}
string formula = new string(indicador.Formula);
int posicaoInicial = -1;
while ((posicaoInicial = formula.IndexOf('[')) != -1)
{
ushort quantidadeCaracteresAteOFim = ObterQuantidadeCaracteresAteOFimDaExpressa(indicador.Formula, posicaoInicial);
string indicadorFormula = indicador.Formula.Substring(posicaoInicial, quantidadeCaracteresAteOFim).Replace("[", "").Replace("]", "");
if (string.IsNullOrWhiteSpace(indicadorFormula))
{
throw new Exception($"Fórmula inválida. '{indicador.Formula}'.");
}
var novoIndicador = indicadorRepository.Find($"Identificador = '{indicadorFormula}'");
if (novoIndicador is null)
{
throw new Exception($"Não foi possível localizar um indicador com este identificador: '{indicadorFormula}'.");
}
decimal valor = meta ? ObterValorMetaMovimento(idProjeto, novoIndicador, dataInicial, dataFinal) : ObterValorRealizadoMovimento(idProjeto, novoIndicador, dataInicial, dataFinal);
string valorFormatado = valor.ToString().Replace(".", "").Replace(",", ".");
formula = formula.Replace($"[{indicadorFormula}]", valorFormatado);
}
return(ObterValorFormula(formula));
}
public ProcessResult <IndicadorResponse> RegistrarIndicador(IndicadorRequest data)
{
ProcessResult <IndicadorResponse> resultado = new ProcessResult <IndicadorResponse>();
resultado.Result = new IndicadorResponse();
try
{
using (TransactionScope ts = new TransactionScope())
{
IndicadorEntity indicadorSincronizar = indicadorEntityRepository.GetById(data.CodigoIndicador);
IndicadorEntity indicadorGeneral = Mapper.Map <IndicadorRequest, IndicadorEntity>(data);
if (indicadorSincronizar != null)
{
if (data.CodigoFormula != null)
{
indicadorSincronizar.CodigoFormula = data.CodigoFormula;
}
if (indicadorSincronizar.CodigoFormula != null)
{
indicadorGeneral.CodigoFormula = indicadorSincronizar.CodigoFormula;
}
Mapper.Map <IndicadorEntity, IndicadorEntity>(indicadorSincronizar, indicadorGeneral);
indicadorEntityRepository.Editar(indicadorSincronizar);
resultado.Result.CodigoIndicador = data.CodigoIndicador;
}
else
{
indicadorEntityRepository.Insertar(indicadorGeneral);
bool registroExitoso = resultado.IsSuccess;
if (!registroExitoso)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <IndicadorService>(MensajesSistemaResource.EtiquetaError);
}
}
resultado.Result.CodigoIndicador = indicadorGeneral.CodigoIndicador;
if (data.ListaIndicadorAmbito != null && data.ListaIndicadorAmbito.Count > 0)
{
this.EliminarIndicadorAmbito(indicadorGeneral);
this.GuardarIndicadorAmbito(data.ListaIndicadorAmbito, indicadorGeneral);
}
indicadorEntityRepository.GuardarCambios();
ts.Complete();
}
}
catch (Exception ex)
{
resultado.IsSuccess = false;
resultado.Exception = new ApplicationLayerException <IndicadorService>(ex.Message);
}
return(resultado);
}
/// <summary>
/// Permite eliminar Indicador Ambito
/// </summary>
public void EliminarIndicadorAmbito(IndicadorEntity data)
{
List <IndicadorAmbitoEntity> lstIndicadorAmbito = indicadorAmbitoEntityRepository.GetFiltered(x => x.CodigoIndicador == data.CodigoIndicador && x.EstadoRegistro == DatosConstantes.EstadoRegistro.Activo).ToList();
for (int i = 0; i < lstIndicadorAmbito.Count; i++)
{
Guid codigoIndicadorAmbito = lstIndicadorAmbito[i].CodigoIndicadorAmbito.Value;
indicadorAmbitoEntityRepository.Eliminar(codigoIndicadorAmbito);
indicadorAmbitoEntityRepository.GuardarCambios();
}
}
private ResultadoCalculo ObterResultadosCalculados(IndicadorEntity indicador, long idProjeto, DateTime dataInicial, DateTime dataFinal)
{
var resultadoCalculo = new ResultadoCalculo
{
ValorMeta = ObterValorCalculado(indicador, idProjeto, dataInicial, dataFinal),
ValorRealizado = ObterValorCalculado(indicador, idProjeto, dataInicial, dataFinal, false)
};
resultadoCalculo.ValorAtingimento = ObterValorAtingimento(indicador, resultadoCalculo.ValorMeta, resultadoCalculo.ValorRealizado);
DefinirPropriedadesIndicador(indicador, resultadoCalculo);
return(resultadoCalculo);
}
private void DefinirPropriedadesIndicador(IndicadorEntity indicador, ResultadoCalculo resultado)
{
resultado.Identificador = indicador.Identificador;
resultado.UnidadeMedida = $"{indicador.UnidadeMedida.Codigo} - {indicador.UnidadeMedida.Descricao}";
resultado.UsuarioResponsavel = indicador.UsuarioResponsavel.Nome;
switch (indicador.TipoCardinalidade)
{
case TipoCardinalidade.Exata: resultado.Cardinalidade = "Exata"; break;
case TipoCardinalidade.QuantoMaiorMelhor: resultado.Cardinalidade = "Quanto maior melhor"; break;
case TipoCardinalidade.QuantoMenorMelhor: resultado.Cardinalidade = "Quanto menor melhor"; break;
default: throw new Exception($"Tipo de cardinalidade inválida no indicador: '{indicador.Identificador}'.");
}
}
public ProcessResult <object> EliminarIndicador(IndicadorRequest filtro)
{
ProcessResult <object> resultado = new ProcessResult <object>();
resultado.Result = string.Empty;
try
{
IndicadorEntity oIndicadorEntity = indicadorEntityRepository.GetById(filtro.CodigoIndicador);
if (oIndicadorEntity != null)
{
indicadorEntityRepository.Eliminar(oIndicadorEntity.CodigoIndicador);
resultado.IsSuccess = true;
indicadorEntityRepository.GuardarCambios();
}
}
catch (Exception ex)
{
resultado.Exception = new ApplicationLayerException <IndicadorService>(ex.Message);
}
return(resultado);
}
private decimal ObterValorRealizadoMovimento(long idProjeto, IndicadorEntity indicadorEntity, DateTime dataInicial, DateTime dataFinal)
{
string tipoOperacao = indicadorEntity.TipoAcumuloRealizado == TipoAcumulo.Media ? "avg" : "sum";
string sql = $"select round(coalesce({tipoOperacao}(ValorRealizado), 0), 2) valor from Movimento where IdProjeto = {idProjeto} and IdIndicador = {indicadorEntity.IdIndicador} ";
if (indicadorEntity.TipoAcumuloRealizado == TipoAcumulo.NaoAcumulavel)
{
sql += "and DataLancamento = :P1";
var database = DatabaseProvider.NewQuery(sql);
database.AddParameter("P1", dataInicial.Date);
database.ExecuteQuery();
return(database.GetDecimal("VALOR"));
}
else
{
sql += "and DataLancamento Between :P1 and :P2";
var database = DatabaseProvider.NewQuery(sql);
database.AddParameter("P1", dataInicial.Date);
database.AddParameter("P2", dataFinal.Date);
database.ExecuteQuery();
return(database.GetDecimal("VALOR"));
}
}
/// <summary>
/// Permite registar Indicador Gestion
/// </summary>
public void GuardarIndicadorAmbito(List <IndicadorAmbitoRequest> lstIndicadorAmbito, IndicadorEntity data)
{
for (int i = 0; i < lstIndicadorAmbito.Count; i++)
{
lstIndicadorAmbito[i].CodigoIndicador = data.CodigoIndicador.Value;
IndicadorAmbitoEntity indicadorAmbitoGeneral = Mapper.Map <IndicadorAmbitoRequest, IndicadorAmbitoEntity>(lstIndicadorAmbito[i]);
indicadorAmbitoEntityRepository.Insertar(indicadorAmbitoGeneral);
indicadorAmbitoEntityRepository.GuardarCambios();
}
}
