protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
IndicadorViewModel indicadorViewModel = (IndicadorViewModel)value;
if ((indicadorViewModel != null && indicadorViewModel.MetaAceptableViewModel != null) || indicadorViewModel.Id > 0)
{
IMedicionService medicionService = DependencyResolver.Current.GetService <IMedicionService>();
EscalaGraficosViewModel escalas = medicionService.ObtenerEscalasGrafico(indicadorViewModel);
decimal[] escalaValores = escalas.EscalaValores;
if (escalaValores[0] <= escalaValores[1] &&
escalaValores[1] <= escalaValores[2] &&
escalaValores[2] <= escalaValores[3] &&
escalaValores[3] <= escalaValores[4] &&
escalaValores[4] <= escalaValores[5])
{
return(null);
}
else
{
return(new ValidationResult("Verifique que los rangos de las metas sean correctos."));
}
}
else
{
return(null);
}
}
private bool HayCambios(Indicador indicadorOriginal, IndicadorViewModel indicadorCargado)
{
if (!indicadorOriginal.Nombre.Trim().Equals(indicadorCargado.Nombre.Trim()) ||
!indicadorOriginal.Descripcion.Trim().Equals(indicadorCargado.Descripcion.Trim()))
{
return(true);
}
if (!indicadorOriginal.ObjetivoID.ToString().Trim().Equals(indicadorCargado.ObjetivoID.Trim()) ||
!indicadorOriginal.FrecuenciaMedicionIndicadorID.ToString().Trim().Equals(indicadorCargado.FrecuenciaMedicionIndicadorID.Trim()))
{
return(true);
}
if (MetasDiferentes(indicadorOriginal.MetaAceptable, indicadorCargado.MetaAceptableViewModel) ||
MetasDiferentes(indicadorOriginal.MetaAMejorar, indicadorCargado.MetaAMejorarViewModel) ||
MetasDiferentes(indicadorOriginal.MetaExcelente, indicadorCargado.MetaExcelenteViewModel) ||
MetasDiferentes(indicadorOriginal.MetaInaceptable, indicadorCargado.MetaInaceptableViewModel) ||
MetasDiferentes(indicadorOriginal.MetaSatisfactoria, indicadorCargado.MetaSatisfactoriaViewModel))
{
return(true);
}
if (InteresadosDiferentes(indicadorOriginal.Interesados, indicadorCargado.Interesados))
{
return(true);
}
if (ResponsablesDiferentes(indicadorOriginal.Responsables, indicadorCargado.Responsables))
{
return(true);
}
return(false);
}
public async Task <ActionResult> Crear(string idObjetivo)
{
IndicadorViewModel model = new IndicadorViewModel();
model.Titulo = "Indicadores";
model.FechaCreacion = DateTime.Now.ToString("dd/MM/yyyy HH:mm tt");
// Por el momento solo frecuencias mensuales
model.FrecuenciaMedicionIndicadorViewModel = (await FrecuenciaMedicionIndicadorService.Buscar(new FrecuenciaMedicionIndicadorViewModel {
Descripcion = "Mensual"
})).FirstOrDefault();
Session["InteresadosSeleccionados"] = model.Interesados;
Session["ResponsablesSeleccionados"] = model.Responsables;
model.PersonaLogueadaViewModel = (PersonaViewModel)Session["Persona"];
if (model.PersonaLogueadaViewModel.AreaViewModel != null)
{
model.ObjetivoViewModel.AreaViewModel = model.PersonaLogueadaViewModel.AreaViewModel;
model.AreaID = model.ObjetivoViewModel.AreaViewModel.Id.ToString();
}
if (idObjetivo != null)
{
model.ObjetivoViewModel = await ObjetivoService.GetById(Int32.Parse(idObjetivo));
}
ViewBag.Titulo = model.Titulo;
return(View(model));
}
public async Task <ActionResult> Ver(string id, string msgExito)
{
IndicadorViewModel model = await IndicadorService.GetById(Int32.Parse(id));
model.Titulo = "Indicadores";
ViewBag.Titulo = model.Titulo;
ViewBag.MensageExito = msgExito;
return(View(model));
}
public IActionResult Put([FromBody] IndicadorViewModel indicador)
{
if (!ModelState.IsValid)
{
NotifyModelStateErrors();
return(Response(indicador));
}
_indicadorAppService.Update(indicador);
return(Response(indicador));
}
public async Task <IndicadorViewModel> GetById(int id)
{
Indicador indicador = await IndicadorRepository.GetById(id).FirstAsync();
IndicadorViewModel indicadorViewModel = AutoMapper.Mapper.Map <IndicadorViewModel>(indicador);
indicadorViewModel.ObjetivoViewModel = AutoMapper.Mapper.Map <ObjetivoViewModel>(indicador.Objetivo);
indicadorViewModel.ObjetivoViewModel.AreaViewModel = AutoMapper.Mapper.Map <AreaViewModel>(indicador.Objetivo.Area);
indicadorViewModel.FrecuenciaMedicionIndicadorViewModel = AutoMapper.Mapper.Map <FrecuenciaMedicionIndicadorViewModel>(indicador.FrecuenciaMedicion);
indicadorViewModel.Interesados = AutoMapper.Mapper.Map <IList <PersonaViewModel> >(indicador.Interesados.Select(i => i.Persona));
indicadorViewModel.Responsables = AutoMapper.Mapper.Map <IList <PersonaViewModel> >(indicador.Responsables.Select(i => i.Persona));
return(indicadorViewModel);
}
public void EjecutarIndicador(IndicadorViewModel indicadorViewModel)
{
lock (thisLock)
{
int mesACalcular = 0;
int anioACalcular = 0;
if (DateTimeHelper.OntenerFechaActual().Month == 1)
{
mesACalcular = 12;
anioACalcular = DateTimeHelper.OntenerFechaActual().Year - 1;
}
else
{
mesACalcular = DateTimeHelper.OntenerFechaActual().Month - 1;
anioACalcular = DateTimeHelper.OntenerFechaActual().Year;
}
// Calcular las mediciones del mes anterior
Enums.Enum.Mes mesAnterior = Helpers.EnumHelper <Enums.Enum.Mes> .Parse(mesACalcular.ToString());
MedicionViewModel medicionMes = GetMedicionService().BuscarNoTask(new MedicionViewModel {
Grupo = indicadorViewModel.Grupo, Mes = mesAnterior, Anio = anioACalcular
}).FirstOrDefault();
IList <MedicionResultDTO> medicionesNuevas = null;
// Guardar la medición sólo si no tiene
if (medicionMes == null)
{
medicionesNuevas = ObtenerDetallesMediciones(mesACalcular, anioACalcular);
medicionMes = GetMedicionService().ObtenerMedicionViewModelNoTask(indicadorViewModel.Id, (int)mesAnterior, null, indicadorViewModel.Grupo, anioACalcular, null);
medicionMes.FechaCarga = DateTimeHelper.OntenerFechaActual().ToString("dd/MM/yyyy HH:mm tt");
medicionMes.UsuarioCargo = "Automático Sistema";
medicionMes.Anio = anioACalcular;
medicionMes.Valor = ObtenerValorMedicionCPI(medicionesNuevas).ToString().Replace(",", ".").TrimEnd('0').TrimEnd('.');
if (string.IsNullOrEmpty(medicionMes.Valor))
{
medicionMes.Valor = "0";
}
medicionMes.MedicionId = GetMedicionService().GuardarMedicionNoTask(medicionMes);
}
// Generar excel con el detalle
GenerarExcel((int)medicionMes.Mes, medicionMes.Anio, indicadorViewModel.Id, (List <MedicionResultDTO>)medicionesNuevas);
}
}
public async Task <IndicadorViewModel> GetUltimoByGrupo(long grupo, PersonaViewModel personaViewModel, bool buscarTodasLasAreas = false)
{
// Obtener el nombre del último indicador del grupo.
Indicador indicador = await IndicadorRepository.Buscar(new BuscarIndicadorViewModel { Busqueda = new IndicadorViewModel {
Grupo = grupo
}, PersonaLogueadaViewModel = personaViewModel, TodasLasAreas = buscarTodasLasAreas }).FirstAsync();
IndicadorViewModel indicadorViewModel = AutoMapper.Mapper.Map <IndicadorViewModel>(indicador);
indicadorViewModel.ObjetivoViewModel = AutoMapper.Mapper.Map <ObjetivoViewModel>(indicador.Objetivo);
indicadorViewModel.ObjetivoViewModel.AreaViewModel = AutoMapper.Mapper.Map <AreaViewModel>(indicador.Objetivo.Area);
indicadorViewModel.FrecuenciaMedicionIndicadorViewModel = AutoMapper.Mapper.Map <FrecuenciaMedicionIndicadorViewModel>(indicador.FrecuenciaMedicion);
indicadorViewModel.Interesados = AutoMapper.Mapper.Map <IList <PersonaViewModel> >(indicador.Interesados.Select(i => i.Persona));
indicadorViewModel.Responsables = AutoMapper.Mapper.Map <IList <PersonaViewModel> >(indicador.Responsables.Select(i => i.Persona));
return(indicadorViewModel);
}
public async Task <ActionResult> Editar(string id, string msgExito)
{
IndicadorViewModel model = await IndicadorService.GetById(Int32.Parse(id));
model.CantidadInteresadosElegidos = model.Interesados.Count;
model.CantidadResponsablesElegidos = model.Responsables.Count;
model.PersonaLogueadaViewModel = (PersonaViewModel)Session["Persona"];
model.Titulo = "Indicadores";
Session["InteresadosSeleccionados"] = model.Interesados;
Session["ResponsablesSeleccionados"] = model.Responsables;
ViewBag.Titulo = model.Titulo;
ViewBag.MensageExito = msgExito;
return(View(model));
}
public async Task <ActionResult> Crear(IndicadorViewModel model)
{
model.PersonaLogueadaViewModel = (PersonaViewModel)Session["Persona"];
if (model.PersonaLogueadaViewModel.AreaViewModel != null)
{
model.ObjetivoViewModel.AreaViewModel = model.PersonaLogueadaViewModel.AreaViewModel;
model.AreaID = model.ObjetivoViewModel.AreaViewModel.Id.ToString();
}
model.FrecuenciaMedicionIndicadorViewModel = await FrecuenciaMedicionIndicadorService.GetById(Int32.Parse(model.FrecuenciaMedicionIndicadorID));
if (!String.IsNullOrEmpty(model.ObjetivoID) && !model.ObjetivoID.Equals("0"))
{
model.ObjetivoViewModel = await ObjetivoService.GetById(Int32.Parse(model.ObjetivoID));
}
model.Interesados = (IList <PersonaViewModel>)Session["InteresadosSeleccionados"];
model.Responsables = (IList <PersonaViewModel>)Session["ResponsablesSeleccionados"];
model.CantidadInteresadosElegidos = model.Interesados.Count;
model.CantidadResponsablesElegidos = model.Responsables.Count;
if (!ModelState.IsValid)
{
ModelState.AddModelError(string.Empty, "Verifique que todos los campos estén cargados y sean correctos.");
return(View(model));
}
model.Titulo = "Indicadores";
ViewBag.Titulo = model.Titulo;
PersonaViewModel persona = (PersonaViewModel)Session["Persona"];
int idIndicador = await IndicadorService.Guardar(model, persona);
object parametros = new { q = MyExtensions.Encrypt(new { id = idIndicador, msgExito = "El indicador se ha guardado exitosamente." }) };
return(RedirectToAction("Editar", "Indicador", parametros));
}
public void Register(IndicadorViewModel indicadorViewModel)
{
IEnumerable <IndicadorEscopoAreaViewModel> listIndicadorEscopoArea = new List <IndicadorEscopoAreaViewModel>();
var registerCommand = _mapper.Map <CadastrarIndicadorCommand>(indicadorViewModel);
registerCommand.Id = Guid.NewGuid();
var result = Bus.SendCommand(registerCommand);
if (result.IsCompleted)
{
listIndicadorEscopoArea = TransformaIndicadorEmIndicadorEscopoArea(indicadorViewModel);
}
foreach (var indicadorEscopoArea in listIndicadorEscopoArea)
{
indicadorEscopoArea.IndicadorId = registerCommand.Id;
var registerEscopoAreaCommand = _mapper.Map <CadastrarIndicadorEscopoAreaCommand>(indicadorEscopoArea);
Bus.SendCommand(registerEscopoAreaCommand);
}
}
public async Task <MedicionViewModel> ObtenerMedicionViewModel(int idIndicador, int mes, int?idMedicion, long grupo, int anio, PersonaViewModel personaViewModel, bool buscarTodasLasAreas = false)
{
MedicionViewModel medicionViewModel = new MedicionViewModel();
medicionViewModel.Mes = Helpers.EnumHelper <Enums.Enum.Mes> .Parse(mes.ToString());
medicionViewModel.IndicadorID = idIndicador;
// Obtener el nombre del último indicador del grupo.
IndicadorViewModel indicadorViewModel = await IndicadorService.GetUltimoByGrupo(grupo, personaViewModel, buscarTodasLasAreas);
if (idMedicion != null)
{
medicionViewModel = await this.GetById(idMedicion.Value);
}
else
{
medicionViewModel.IndicadorViewModel = indicadorViewModel;
}
medicionViewModel.IndicadorViewModel.Nombre = indicadorViewModel.Nombre;
return(medicionViewModel);
}
public MedicionViewModel ObtenerMedicionViewModelNoTask(int idIndicador, int mes, int?idMedicion, long grupo, int anio, PersonaViewModel personaViewModel)
{
MedicionViewModel medicionViewModel = new MedicionViewModel();
medicionViewModel.Mes = Helpers.EnumHelper <Enums.Enum.Mes> .Parse(mes.ToString());
medicionViewModel.IndicadorID = idIndicador;
// Obtener el nombre del último indicador del grupo.
IndicadorViewModel indicadorViewModel = IndicadorService.GetUltimoByGrupoNoTask(grupo, personaViewModel);
if (idMedicion != null)
{
medicionViewModel = this.GetByIdNoTask(idMedicion.Value);
}
else
{
medicionViewModel.IndicadorViewModel = indicadorViewModel;
}
medicionViewModel.IndicadorViewModel.Nombre = indicadorViewModel.Nombre;
return(medicionViewModel);
}
public IEnumerable <IndicadorEscopoAreaViewModel> TransformaIndicadorEmIndicadorEscopoArea(IndicadorViewModel indicador)
{
var lista = new List <IndicadorEscopoAreaViewModel>();
foreach (var indicadorEscopoAreaFor in indicador.IndicadorEscopoAreas)
{
var indicadorEscopoArea = new IndicadorEscopoAreaViewModel();
indicadorEscopoArea.IndicadorId = indicadorEscopoAreaFor.Id;
indicadorEscopoArea.EscopoId = indicadorEscopoAreaFor.EscopoId;
indicadorEscopoArea.AreaId = indicadorEscopoAreaFor.AreaId;
lista.Add(indicadorEscopoArea);
}
return(lista);
}
public void Update(IndicadorViewModel indicadorViewModel)
{
var updateCommand = _mapper.Map <AtualizarIndicadorCommand>(indicadorViewModel);
Bus.SendCommand(updateCommand);
}
public EscalaGraficosViewModel ObtenerEscalasGrafico(IndicadorViewModel indicador)
{
EscalaGraficosViewModel escalas = new EscalaGraficosViewModel();
decimal valorExcelente =
ObtenerValorEscala(indicador.MetaExcelenteViewModel, indicador.MetaSatisfactoriaViewModel);
decimal valorSatisfactorio =
ObtenerValorEscala(indicador.MetaSatisfactoriaViewModel, indicador.MetaAceptableViewModel);
decimal valorAceptable =
ObtenerValorEscala(indicador.MetaAceptableViewModel, indicador.MetaAMejorarViewModel);
decimal valorAMejorar =
ObtenerValorEscala(indicador.MetaAMejorarViewModel, indicador.MetaInaceptableViewModel);
if (valorExcelente >= valorSatisfactorio)
{
decimal minimoEscala = 0;
if (!string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) &&
!string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor2))
{
minimoEscala = decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) < decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ","));
}
else
{
minimoEscala = string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ","));
}
decimal maximoEscala = 0;
if (!string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) &&
!string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor2))
{
maximoEscala = decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) > decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ","));
}
else
{
maximoEscala = string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ","));
}
escalas.EscalaValores = new decimal[6] {
minimoEscala, valorAMejorar, valorAceptable, valorSatisfactorio, valorExcelente, maximoEscala
};
escalas.EscalaColores = ColorMetaInaceptableExcelente;
escalas.EscalaDeInaceptableAExcelente = true;
}
else
{
decimal maximoEscala = 0;
if (!string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) &&
!string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor2))
{
maximoEscala = decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) > decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ","));
}
else
{
maximoEscala = string.IsNullOrEmpty(indicador.MetaInaceptableViewModel.Valor1) ? decimal.Parse(indicador.MetaInaceptableViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaInaceptableViewModel.Valor1.Replace(".", ","));
}
decimal minimoEscala = 0;
if (!string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) &&
!string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor2))
{
minimoEscala = decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) < decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ","));
}
else
{
minimoEscala = string.IsNullOrEmpty(indicador.MetaExcelenteViewModel.Valor1) ? decimal.Parse(indicador.MetaExcelenteViewModel.Valor2.Replace(".", ",")) : decimal.Parse(indicador.MetaExcelenteViewModel.Valor1.Replace(".", ","));
}
escalas.EscalaValores = new decimal[6] {
minimoEscala, valorExcelente, valorSatisfactorio, valorAceptable, valorAMejorar, maximoEscala
};
escalas.EscalaColores = ColorMetaExcelenteInaceptable;
escalas.EscalaDeInaceptableAExcelente = false;
}
return(escalas);
}
public async Task <int> Guardar(IndicadorViewModel indicadorViewModel, PersonaViewModel personaGuarda)
{
bool modificado = false;
int mesActual = DateTimeHelper.OntenerFechaActual().Month;
int idIndicadorOriginal = 0;
if (indicadorViewModel.Id > 0)
{
Indicador indicadorOriginal = IndicadorRepository.GetById(indicadorViewModel.Id).First();
if (HayCambios(indicadorOriginal, indicadorViewModel) && await MedicionRepository.Buscar(new MedicionViewModel {
IndicadorID = indicadorViewModel.Id
}).AnyAsync(m => (int)m.Mes != mesActual))
{
idIndicadorOriginal = indicadorViewModel.Id;
indicadorViewModel.Id = 0;
modificado = true;
}
}
// Borrar los responsables previos
await ResponsableIndicadorRepository.EliminarPorIndicador(indicadorViewModel.Id);
// Borrar los interesados previos
await InteresadoIndicadorRepository.EliminarPorIndicador(indicadorViewModel.Id);
// Borrar los permisos previos
await AccesoIndicadorRepository.EliminarPorIndicador(indicadorViewModel.Id);
Indicador indicador = AutoMapper.Mapper.Map <Indicador>(indicadorViewModel);
if (modificado)
{
indicador.FechaCreacion = indicador.FechaCreacion.Value.AddMinutes(1);
}
indicador.MetaAceptableMetaID = await GuardarMeta(indicadorViewModel.MetaAceptableViewModel);
indicador.MetaAMejorarMetaID = await GuardarMeta(indicadorViewModel.MetaAMejorarViewModel);
indicador.MetaExcelenteMetaID = await GuardarMeta(indicadorViewModel.MetaExcelenteViewModel);
indicador.MetaInaceptableMetaID = await GuardarMeta(indicadorViewModel.MetaInaceptableViewModel);
indicador.MetaSatisfactoriaMetaID = await GuardarMeta(indicadorViewModel.MetaSatisfactoriaViewModel);
// Guardar el indicador
await IndicadorRepository.Guardar(indicador);
if (indicador.Grupo == 0)
{
indicador.Grupo = indicador.IndicadorID;
await IndicadorRepository.Guardar(indicador);
}
if (modificado)
{
IndicadorAutomatico indicadorAutomatico = await IndicadorAutomaticoRepository.GetByIdIndicador(idIndicadorOriginal).FirstOrDefaultAsync();
if (indicadorAutomatico != null)
{
indicadorAutomatico.Indicador = null;
indicadorAutomatico.IndicadorID = indicador.IndicadorID;
await IndicadorAutomaticoRepository.Guardar(indicadorAutomatico);
IndicadorAutomaticoViewModel indicadorAutomaticoViewModel = AutoMapper.Mapper.Map <IndicadorAutomaticoViewModel>(indicadorAutomatico);
IndicadorAutomaticoRepository.DetenerJob(indicadorAutomaticoViewModel);
IndicadorAutomaticoRepository.IniciarJob(indicadorAutomaticoViewModel);
}
}
// Guardar los responsables
await GuardarResponsables(indicadorViewModel.Responsables, indicador.IndicadorID);
// Guardar los interesados
await GuardarInteresados(indicadorViewModel.Interesados, indicador.IndicadorID);
if (modificado)
{
// Si hay mediciones cargadas para el indicador que se esta modificando, actualizar la referencia al nuevo indicador
IList <Medicion> mediciones = MedicionRepository.Buscar(new MedicionViewModel {
IndicadorID = idIndicadorOriginal, Mes = (Enums.Enum.Mes)mesActual
}).ToList();
if (mediciones != null && mediciones.Count > 0)
{
foreach (Medicion medicion in mediciones)
{
medicion.IndicadorID = indicador.IndicadorID;
await MedicionRepository.Guardar(medicion);
}
}
}
await AuditarModificacionIndicador(personaGuarda);
return(indicador.IndicadorID);
}