/// <summary>
/// Retorna un vector con parejas de nombre y valor
/// que reflejan una serie de indicadores:
/// n_solPro = Número de solicitudes de proveedores
/// n_solProA = Núemro de solicitudes aceptadas.
/// n_solProR = Número de solicitudes rechazadas
/// </summary>
/// <param name="tk">Tique de autorización (ver Login)</param>
/// <returns></returns>
public virtual IEnumerable<Indicador> Get(string tk)
{
IList<Indicador> lindi = new List<Indicador>();
Indicador indi = null;
using (PortalProContext ctx = new PortalProContext())
{
if (CntWebApiSeguridad.CheckTicket(tk, ctx))
{
// Se van obteniendo uno a uno y aplciando a lista
// Número solicitudes de proveedor
int n_solPro = (from p in ctx.SolicitudProveedors
select p).Count();
indi = new Indicador()
{
id = "n_solPro",
valor = (decimal)n_solPro
};
lindi.Add(indi);
// Número de solicitudes aprobadas
int n_solProA = (from p in ctx.SolicitudProveedors
where p.SolicitudStatus.SolicitudStatusId == 2
select p).Count();
indi = new Indicador()
{
id = "n_solProA",
valor = (decimal)n_solProA
};
lindi.Add(indi);
// Número de solicitudes rechazadas
int n_solProR = (from p in ctx.SolicitudProveedors
where p.SolicitudStatus.SolicitudStatusId == 3
select p).Count();
indi = new Indicador()
{
id = "n_solProR",
valor = (decimal)n_solProR
};
lindi.Add(indi);
int n_solProP = (from p in ctx.SolicitudProveedors
where p.SolicitudStatus.SolicitudStatusId == 1
select p).Count();
indi = new Indicador()
{
id = "n_solProP",
valor = (decimal)n_solProP
};
lindi.Add(indi);
return lindi;
}
else
{
throw new HttpResponseException(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "Se necesita tique de autorización (SolicitudLogs)"));
}
}
}
public ActionResult Delete(Indicador indicador)
{
var indicadorCurrent = _context.IndicadorSet.SingleOrDefault(o => o.Id == indicador.Id);
if (indicadorCurrent == null)
{
return(HttpNotFound());
}
indicadorCurrent.Activo = false;
_context.SaveChanges();
return(RedirectToAction("Index", "Indicador"));
}
public async Task <Response> PostIndicador([FromBody] Indicador Indicador)
{
try
{
if (!ModelState.IsValid)
{
return(new Response
{
IsSuccess = false,
Message = Mensaje.ModeloInvalido
});
}
var respuesta = Existe(Indicador);
if (!respuesta.IsSuccess)
{
db.Indicador.Add(Indicador);
await db.SaveChangesAsync();
return(new Response
{
IsSuccess = true,
Message = Mensaje.Satisfactorio
});
}
return(new Response
{
IsSuccess = false,
Message = Mensaje.ExisteRegistro
});
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.SwTH),
ExceptionTrace = ex.Message,
Message = Mensaje.Excepcion,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Critical),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "",
});
return(new Response
{
IsSuccess = false,
Message = Mensaje.Error,
});
}
}
public decimal PatrimonioNeto(List <Cuenta> Cuentas)
{
Indicador indicadorActual = new Indicador();
indicadorActual = db.Indicadores.Where(c => c.Nombre.Equals("IngresoNeto")).First();
decimal SumatoriaNEtoEmpresa = 0;
for (int i = 0; i < Cuentas.Count; i++)
{
SumatoriaNEtoEmpresa += evaluarIndicador(indicadorActual.Formula, Cuentas[i].Valor, Cuentas);
}
return(SumatoriaNEtoEmpresa);
}
// GET: Maquinaria/Indicador/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Indicador indicadores = db.Indicadores.Find(id);
if (indicadores == null)
{
return(HttpNotFound());
}
return(View(indicadores));
}
public Object dmlAgregar(Indicador oDatos)
{
String sSQL = " INSERT INTO TCE_IND_INDICADOR( ARACLAVE, IndClave, GPOCLAVE, IndAño, IndUniID, IndReporta, IndConsecutivo, IndNombre, " +
"IndDescripcion, IndMin, IndSat, IndSob, IndResultado, IndSemaforo, IndAvance, IndCalificacion, IndPonderacion, IndFormula, " +
"IndUnidad, IndPeriodicidad, IndValor, IndProveedor, IndResponsable, IndCorreo, IndComentarios, IndTipoCalculo, IndMPP, " +
"IndNotaCalculo, IndTipoObj, IndTipoAvance, IndAvanceProj, IndExcepcionCalc, IndReglamentoInt, IndTerminado, " +
"IndPonderacionAjuste, IndFechaCalculo, IndOrdenMP) VALUES ("
+ " '" + oDatos.IndUniClave
+ "'," + oDatos.IndClave
+ "," + oDatos.IndGPOCLAVE
+ "," + oDatos.IndAño
+ ",'" + oDatos.IndUniId
+ "'," + oDatos.IndReporta
+ "," + oDatos.IndConsecutivo
+ ",'" + oDatos.IndNombre
+ "','" + oDatos.IndDescripcion
+ "','" + oDatos.IndMin
+ "','" + oDatos.IndSat
+ "','" + oDatos.IndSob
+ "','" + oDatos.IndResultado
+ "'," + oDatos.IndSemaforo
+ "," + oDatos.IndAvance
+ "," + oDatos.IndCalificacion
+ "," + oDatos.IndPonderacion
+ ",'" + oDatos.IndFormula
+ "','" + oDatos.IndUnidad
+ "','" + oDatos.IndPeriodicidad
+ "','" + oDatos.IndValor
+ "','" + oDatos.IndProveedor
+ "','" + oDatos.IndResponsable
+ "','" + oDatos.IndCorreo
+ "','" + oDatos.IndComentarios
+ "'," + oDatos.IndTipoCalculo
+ ",'" + oDatos.IndMPP
+ "','" + oDatos.IndNotaCalculo
+ "'," + oDatos.IndTipoObj
+ "," + oDatos.IndTipoAvance
+ "," + oDatos.IndAvanceProj
+ "," + oDatos.IndExcepcionCalc
+ ",'" + oDatos.IndReglamentoInt
+ "'," + oDatos.IndTerminado
+ "," + oDatos.IndPonderacionAjuste
+ "," + oDatos.IndFechaCalculo
+ "," + oDatos.IndOrdenMP
+ ") ";
return(EjecutaOracleCommand(sSQL));
}
// GET: Indicadors/Details/5
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Indicador indicador = db.Indicador.Find(id);
if (indicador == null)
{
return(HttpNotFound());
}
return(View(indicador));
}
public IHttpActionResult DeleteIndicador(int id)
{
Indicador indicador = db.Indicadores.Find(id);
if (indicador == null)
{
return(NotFound());
}
db.Indicadores.Remove(indicador);
db.SaveChanges();
return(Ok(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 ActionResult Procesar(string nombre, string fórmula)
{
if (!Indicador.NameTaken(nombre))
{
RefreshUserID();
new Indicador(usuarioID, nombre, fórmula);
TempData["Info"] = "Se creó un indicador exitosamente, de nombre \"" + nombre + '"';
}
else
{
TempData["Error"] = "Ya existe un indicador de nombre \"" + nombre + '"';
}
return(RedirectToAction("Menú", "Indicadores"));
}
public async Task <IActionResult> Create(Indicador Indicador)
{
if (!ModelState.IsValid)
{
InicializarMensaje(null);
return(View(Indicador));
}
Response response = new Response();
try
{
response = await apiServicio.InsertarAsync(Indicador,
new Uri(WebApp.BaseAddress),
"api/Indicadores/InsertarIndicador");
if (response.IsSuccess)
{
var responseLog = await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
ExceptionTrace = null,
Message = "Se ha creado un Indicador",
UserName = "******",
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
EntityID = string.Format("{0} {1}", "Indicador:", Indicador.IdIndicador),
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(Indicador));
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Creando Indicador",
ExceptionTrace = ex.Message,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Create),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
// GET: Indicadors/Delete/5
public ActionResult DeleteConfirmed(int id)
{
Indicador indicador = db.Indicador.Find(id);
try
{
db.Indicador.Remove(indicador);
db.SaveChanges();
return(RedirectToAction("Index"));
}
catch (Exception e)
{
return(View());
}
}
public double EvaluarIndicadorParaEmpresa(int idIndicador, string cuit, int periodo, List <Indicador> indicadoresDelUsuario)
{
//Obtengo el indicador y empresa solicitada
Indicador indicador = GetById(idIndicador);
EmpresasService empSv = new EmpresasService(db);
Empresa empresa = empSv.GetByCUIT(cuit);
//Aplico el indicador, es decir, hay que parsear la formula
List <ComponenteOperando> listaOperandos = new List <ComponenteOperando>();
listaOperandos.AddRange(db.Operandos.OfType <Cuenta>());
listaOperandos.AddRange(indicadoresDelUsuario);
double valorTrasAplicarIndicador = indicador.ObtenerValor(empresa, periodo, listaOperandos);
return(valorTrasAplicarIndicador);
}
public string GetFilter(int companyId, int indicatorType, DateTime?from, DateTime?to, int?processId, int?processTypeId, int?targetId, int status)
{
var filter = new StringBuilder("{");
filter.Append(Tools.JsonPair("companyId", companyId)).Append(",");
filter.Append(Tools.JsonPair("indicatorType", indicatorType)).Append(",");
filter.Append(Tools.JsonPair("from", from)).Append(",");
filter.Append(Tools.JsonPair("to", to)).Append(",");
filter.Append(Tools.JsonPair("process", processId)).Append(",");
filter.Append(Tools.JsonPair("processType", processTypeId)).Append(",");
filter.Append(Tools.JsonPair("objetivo", targetId)).Append(",");
filter.Append(Tools.JsonPair("status", status)).Append("}");
Session["IndicadorFilter"] = filter.ToString();
return(Indicador.FilterList(companyId, indicatorType, from, to, processId, processTypeId, targetId, status));
}
public void AtualizarContinuacao(Indicador indicador)
{
string SQL = @"UPDATE Indicador SET
DataEnvioEmailContinuacao=@DataEnvioEmailContinuacao
,DataModificacao=@DataModificacao
,QuantidadeEmailContinuacao=@QuantidadeEmailContinuacao
WHERE ID = @ID";
using (DbConnection con = _db.CreateConnection())
{
con.Open();
con.Execute(SQL, indicador);
con.Close();
}
}
public ActionResult ComparativoGeral([Bind("Dado")] Indicador indicador)
{
string nomeIndicador = indicador.Dado;
string nome = "";
List <Nacao> nacoes = _context.Nacoes.ToList();
var eixoX = new List <string>();
var eixoY = new List <decimal>();
foreach (Nacao nacao in nacoes)
{
eixoX.Add(nacao.Nome);
if (nomeIndicador == "Populacao")
{
eixoY.Add(nacao.Populacao);
}
if (nomeIndicador == "IDH")
{
eixoY.Add(nacao.IDH);
}
if (nomeIndicador == "PIB")
{
eixoY.Add(nacao.PIB);
}
}
if (nomeIndicador == "Populacao")
{
nome = "Análise da população";
}
if (nomeIndicador == "IDH")
{
nome = "Análise do IDH";
}
if (nomeIndicador == "PIB")
{
nome = "Análise do PIB";
}
ViewBag.EixoX = eixoX.ToList();
ViewBag.EixoY = eixoY.ToList();
ViewBag.Nome = nome;
return(View());
}
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 <IActionResult> Edit(string id, Indicador Indicador)
{
Response response = new Response();
try
{
if (!string.IsNullOrEmpty(id))
{
response = await apiServicio.EditarAsync(id, Indicador, new Uri(WebApp.BaseAddress),
"/api/Indicadores");
if (response.IsSuccess)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
EntityID = string.Format("{0} : {1}", "Sistema", id),
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ADV),
Message = "Se ha actualizado un registro sistema",
UserName = "******"
});
return(RedirectToAction("Index"));
}
ViewData["Error"] = response.Message;
return(View(Indicador));
}
return(BadRequest());
}
catch (Exception ex)
{
await GuardarLogService.SaveLogEntry(new LogEntryTranfer
{
ApplicationName = Convert.ToString(Aplicacion.WebAppTh),
Message = "Editando un Indicador",
ExceptionTrace = ex,
LogCategoryParametre = Convert.ToString(LogCategoryParameter.Edit),
LogLevelShortName = Convert.ToString(LogLevelParameter.ERR),
UserName = "******"
});
return(BadRequest());
}
}
public async Task <ActionResult> Editpop(int id, int idindicador)
{
NotaIndicador nota = await db.NotaIndicador.FindAsync(id);
var userFull = await userManager.FindByEmailAsync(User.Identity.Name);
//ViewBag.IdCategoria = new SelectList(db.Categorias, "id", "numero");
//ViewBag.UserId = new SelectList(db.Users, "Id", "Nombre");
Indicador indicador = await db.Indicador.FindAsync(idindicador);
List <SelectListItem> usuarioLista = new List <SelectListItem>();
usuarioLista.Add(new SelectListItem()
{
Text = userFull.Nombre + " " + userFull.Apellido, Value = userFull.Id
});
List <SelectListItem> IndicadorLista = new List <SelectListItem>();
IndicadorLista.Add(new SelectListItem()
{
Text = indicador.codigo + " " + indicador.nombre, Value = indicador.id.ToString()
});
List <SelectListItem> EstadoLista = new List <SelectListItem>();
EstadoLista.Add(new SelectListItem()
{
Text = "Abierta", Value = "Abierta"
});
EstadoLista.Add(new SelectListItem()
{
Text = "Cerrada", Value = "Cerrada"
});
ViewBag.IdIndicador = new SelectList(IndicadorLista, "Value", "Text", nota.IdIndicador);
ViewBag.UserId = new SelectList(usuarioLista, "Value", "Text", nota.UserId);
ViewBag.Estado = new SelectList(EstadoLista, "Value", "Text", nota.Estado);
return(View(nota));
}
// GET: Indicadors/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Indicador indicador = db.Indicador.Find(id);
if (indicador == null)
{
return(HttpNotFound());
}
ViewBag.id_frecuencia = new SelectList(db.Frecuencia, "id_frecuencia", "frecuencia1", indicador.id_frecuencia);
ViewBag.id_subprograma = new SelectList(db.Subprograma, "id_sub", "nombre", indicador.id_subprograma);
ViewBag.id_tipo_indicador = new SelectList(db.Tipo_indicador, "id_tipo_indicador", "nombre", indicador.id_tipo_indicador);
ViewBag.id_tema = new SelectList(db.Tema, "id_tema", "nombre", indicador.id_tema);
return(View(indicador));
}
// GET: MantPosvalores/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Indicador indicador = contexto.Indicador.Find(id);
if (indicador == null)
{
return(HttpNotFound());
}
ListaCtaCatalogo(indicador.CtaCatalogo);
ListaEstado(indicador.SiglasEst);
ListaPeriodo(indicador.SiglasPer);
ListaUnidad(indicador.SiglasUni);
return(View(indicador));
}
public async Task <bool> Editpop(NotaIndicador nota)
{
//----------------INICIO EVITA QUE UN USUARIO PUEDA MODIFICAR UNA NOTA CAMBIANDO EL DATA-ID
string notaoldUserId = await db.NotaIndicador.Where(n => n.Id == nota.Id).Select(n => n.UserId).FirstOrDefaultAsync();
var userFull = await userManager.FindByEmailAsync(User.Identity.Name);
if (User.Identity.Name != null)
{
if (userFull.Id == notaoldUserId)
{
//----------------INICIO EVITA QUE UN USUARIO PUEDA MODIFICAR UNA NOTA CAMBIANDO EL DATA-ID
if (ModelState.IsValid)
{
db.Entry(nota).State = EntityState.Modified;
await db.SaveChangesAsync();
return(true);
}
}
}
Indicador indicador = await db.Indicador.FindAsync(nota.IdIndicador);
List <SelectListItem> IndicadorLista = new List <SelectListItem>();
IndicadorLista.Add(new SelectListItem()
{
Text = indicador.codigo + " " + indicador.nombre, Value = indicador.id.ToString()
});
ViewBag.IdIndicador = new SelectList(IndicadorLista, "Value", "Text", "Vale");
List <SelectListItem> usuarioLista = new List <SelectListItem>();
usuarioLista.Add(new SelectListItem()
{
Text = userFull.Nombre + " " + userFull.Apellido, Value = userFull.Id
});
ViewBag.UserId = new SelectList(usuarioLista, "Value", "Text", "Value");
return(false);
}
public async Task <ActionResult> Detailspop(int id)
{
IndicadorsController controlIndicador = new IndicadorsController(db, userManager);
ConfiguracionsController controlConfiguracion = new ConfiguracionsController(db, userManager);
NotaIndicador nota = await db.NotaIndicador.FindAsync(id);
Indicador indicador = await controlIndicador.getFromId(nota.Indicador.id);
if (User.Identity.Name != null)
{
var userFull = await userManager.FindByEmailAsync(User.Identity.Name);
var notasE = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Nota.Editar" && c.Value == "1"));
var super = User.HasClaim(c => (c.Type == "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/Super" && c.Value == "1"));
ViewBag.editar = controlConfiguracion.Editable(userFull.IDDependencia, indicador.Categoria, notasE, super);
ViewBag.visible = true;
ViewBag.configuracion = await controlConfiguracion.Get();
ViewBag.indicador = indicador;
ViewBag.userFull = userFull;
}
else
{
Configuracion config = await controlConfiguracion.Get();
ViewBag.editar = false;
ViewBag.userFull = false;
ViewBag.configuracion = config;
ViewBag.visible = config.libre;
}
return(View(nota));
}
public ActionResult Modificar(string nombreIndicador = null, string fórmula = null)
{
RefreshUserID();
ViewBag.NombresIndicadores = Indicador.GetNombres(usuarioID);
ViewBag.NombreIndicador = ViewBag.Fórmula = "";
if (nombreIndicador != null)
{
ViewBag.NombreIndicador = nombreIndicador;
Indicador i = Indicador.Get(nombreIndicador);
ViewBag.Fórmula = i.Fórmula;
if (fórmula != null)
{
i.Fórmula = fórmula;
i.Save();
TempData["Info"] = "Se modificó exitosamente al indicador de nombre \"" + nombreIndicador + '"';
return(RedirectToAction("Menú", "Indicadores"));
}
}
return(View());
}
public ActionResult Create([Bind(Include = "CtaCatalogo,SiglasEst,SiglasPer,SiglasUni")] Indicador indicador)
{
try
{
if (ModelState.IsValid)
{
contexto.Indicador.Add(indicador);
contexto.SaveChanges();
return(RedirectToAction("Index", "Indicadores"));
}
}
catch (RetryLimitExceededException /* dex */)
{
ModelState.AddModelError("", "No se puede guardar. Intente nuevamente, si el problema persiste, contacte al administrador del sistema.");
}
ListaCtaCatalogo(indicador.CtaCatalogo);
ListaEstado(indicador.SiglasEst);
ListaPeriodo(indicador.SiglasPer);
ListaUnidad(indicador.SiglasUni);
return(View(indicador));
}
protected void Editar_Indicador(object sender, EventArgs e)
{
try
{
Indicador _indicador = new Indicador();
_indicador.Id = (int)ViewState["idIndicadorAccion"];
_indicador.Nombre = txtNombreIndicador.Value;
_indicador.Detalle = txtDetalleIndicador.Value;
_indicador.Anho = ddlCodigoAnho.SelectedValue;
_indicador.FecModificacion = DateTime.Now;
_indicador.UsuModificacion = UsuarioSession().DetCodigo;
_indicadorBusinessLogic.ActualizarIndicador(_indicador);
CargarLista();
Response.Redirect("listadoIndicadores.aspx");
ClientMessageBox.Show("Se modificó el indicador seleccionado", this);
}
catch (Exception ex)
{
Log.Error(ex);
}
}
private Response Existe(Indicador Indicador)
{
var bdd = Indicador.Nombre;
var Indicadorrespuesta = db.Indicador.Where(p => p.Nombre == bdd).FirstOrDefault();
if (Indicadorrespuesta != null)
{
return(new Response
{
IsSuccess = true,
Message = Mensaje.ExisteRegistro,
Resultado = null,
});
}
return(new Response
{
IsSuccess = false,
Resultado = Indicadorrespuesta,
});
}
protected void Submit_inactiveIndicador(object sender, EventArgs e)
{
try
{
Indicador indicador = new Indicador
{
Id = (int)ViewState["idIndicadorAccion"],
UsuModificacion = UsuarioSession().DetCodigo,
FecModificacion = DateTime.Now,
FlActivo = (int)Constantes.EstadoFlag.INACTIVO
};
_indicadorBusinessLogic.InactivarIndicador(indicador);
Limpiar();
CargarLista();
ClientMessageBox.Show("Se inactivo el indicador", this);
}
catch (Exception ex)
{
Log.Error(ex);
}
}
/// <summary>
/// Método que atualiza os dados entidade.
/// </summary>
/// <param name="entidade">Entidade contendo os dados a serem atualizados.</param>
public void Atualizar(Indicador entidade)
{
string SQL = @"UPDATE Indicador SET
FacebookID = @FacebookID
,FacebookToken = @FacebookToken
,DataEnvioEmailContinuacao = @DataEnvioEmailContinuacao
,QuantidadeEmailContinuacao = @QuantidadeEmailContinuacao
,DataCadastro = @DataCadastro
,DataModificacao = @DataModificacao
,Nome = @Nome
,EmailCrt = " + Criptografar(entidade.Email) + @"
WHERE ID=@ID ";
using (DbConnection con = _db.CreateConnection())
{
con.Open();
con.Execute(SQL, entidade);
con.Close();
}
}
protected void Submit_agregar_indicador(object sender, EventArgs e)
{
try
{
Indicador _indicador = new Indicador
{
IdAccion = (int)ViewState["idAccion"],
Detalle = txtDetalleIndicador.Value,
Nombre = txtNombreIndicador.Value,
FecModificacion = DateTime.Now,
UsuModificacion = UsuarioSession().DetCodigo,
};
ViewState["idIndicador"] = _indicadorBusinessLogic.GuardarIndicador(_indicador).ToString();
Limpiar();
CargarLista();
}
catch (Exception ex)
{
Log.Error(ex);
}
}
protected void GridAccion2_RowCommand(object sender, GridViewCommandEventArgs e)
{
string[] arg = new string[2];
arg = e.CommandArgument.ToString().Split(';');
string idEntidad = arg[0];
string idIndicador = arg[1];
string idAccion = arg[2];
if (e.CommandName == "avance")
{
Indicador indicador = _indicadorBusinessLogic.ListarIndicadorForId(int.Parse(idIndicador));
Accion accion = _accionBusinessLogic.BuscarAccionForID(int.Parse(idAccion));
Meta meta = new Meta
{
IdEntidad = int.Parse(idEntidad),
IdIndicador = int.Parse(idIndicador)
};
meta = _metaBusinessLogic.BuscarMetaEnviadUIF(meta);
if (meta == null)
{
Limpiar();
divVisualizarDocumento.Visible = false;
borradorMeta.Visible = false;
}
else
{
Cargar(meta);
}
lblAccionTitulo.Text = accion.Nombre;
lblIndicadorTitulo.Text = indicador.Nombre;
lblIndicadorAnho.Text = indicador.Anho;
System.Text.StringBuilder sb = new System.Text.StringBuilder();
sb.Append(@"<script type='text/javascript'>");
sb.Append("$(document).ready(function() { $('#resultado').modal({backdrop: 'static',keyboard: false}); });");
sb.Append(@"</script>");
System.Web.UI.ScriptManager.RegisterClientScriptBlock(this, this.GetType(), "resultado", sb.ToString(), false);
}
}
public virtual void ShowPhotosWindow(Indicador indic, ImagemIndicador imgIndicador)
{
CheckSpaceManager.instance.photosWindow.FillComments(serviceTags);
CheckSpaceManager.instance.photosWindow.Open();
}
/// <summary>
/// Buscars the entidads.
/// </summary>
/// <param name="entidad">The entidad.</param>
private void BuscarIndicadores(Indicador entidad)
{
CargarLista(entidad);
CargarGrilla();
}
/// <summary>
/// Cargars the lista.
/// </summary>
/// <param name="entidad">The entidad.</param>
private void CargarLista(Indicador entidad)
{
objBLIndicador = new BLIndicador();
listaIndicadores = objBLIndicador.GetIndicadores(entidad);
}
/// <summary>
/// Cargars the entidad.
/// </summary>
private void CargarValoresEnPantalla(int idIndicador)
{
Indicador entidad = listaIndicadores.Find(c => c.idIndicador == idIndicador);
objIndicador = entidad;
if (entidad != null)
{
litEditar.Text = entidad.nombre;
txtEscala.Text = entidad.escala;
txtPesoDefault.Text = entidad.pesoDefault.ToString();
txtPesoMaximo.Text = entidad.pesoMaximo.ToString();
txtPesoMinimo.Text = entidad.pesoMinimo.ToString();
chkMaximiza.Checked = entidad.maximiza;
foreach (ConfigFuncionPreferencia item in entidad.listaConfig)
{
switch (item.idFuncionPreferencia)
{
case 2:
//Cuasi Criterio
txtCCLimIndiferencia.Text = item.valorDefault.ToString("##.00");
break;
case 3:
//Pseudo Criterio con Preferencia Lineal
txtPCLimPreferencia.Text = item.valorDefault.ToString("##.00");
break;
case 4:
//Level Criterio
if (item.idValorFuncionPreferencia == 1)
txtLCLimIndiferencia.Text = item.valorDefault.ToString("##.00");
else
txtLCLimPreferencia.Text = item.valorDefault.ToString("##.00");
break;
case 5:
//Preferencia Lineal y Área de Indiferencia
if (item.idValorFuncionPreferencia == 1)
txtPLLimIndiferencia.Text = item.valorDefault.ToString("##.00");
else
txtPLLimPreferencia.Text = item.valorDefault.ToString("##.00");
break;
case 6:
//Gaussiano
txtGSigma.Text = item.valorDefault.ToString("##.00");
break;
default:
break;
}
}
}
}
/// <summary>
/// Guardars the agenda.
/// </summary>
/// <param name="entidad">The entidad.</param>
private void GuardarEntidad(Indicador entidad)
{
objBLIndicador = new BLIndicador(entidad);
objBLIndicador.Save();
}
/// <summary>
/// Obteners the valores pantalla.
/// </summary>
/// <returns></returns>
private Indicador ObtenerValoresDePantalla()
{
Indicador entidad = new Indicador();
entidad = objIndicador;
entidad.pesoDefault = Convert.ToDecimal(txtPesoDefault.Text);
entidad.pesoMinimo = Convert.ToDecimal(txtPesoMinimo.Text);
entidad.pesoMaximo = Convert.ToDecimal(txtPesoMaximo.Text);
entidad.escala = txtEscala.Text.Trim();
entidad.maximiza = chkMaximiza.Checked;
foreach (ConfigFuncionPreferencia item in entidad.listaConfig)
{
switch (item.idFuncionPreferencia)
{
case 2:
//Cuasi Criterio
item.valorDefault = Convert.ToDecimal(txtCCLimIndiferencia.Text);
break;
case 3:
//Pseudo Criterio con Preferencia Lineal
item.valorDefault = Convert.ToDecimal(txtPCLimPreferencia.Text);
break;
case 4:
//Level Criterio
if (item.idValorFuncionPreferencia == 1)
item.valorDefault = Convert.ToDecimal(txtLCLimIndiferencia.Text);
else
item.valorDefault = Convert.ToDecimal(txtLCLimPreferencia.Text);
break;
case 5:
//Preferencia Lineal y Área de Indiferencia
if (item.idValorFuncionPreferencia == 1)
item.valorDefault = Convert.ToDecimal(txtPLLimIndiferencia.Text);
else
item.valorDefault = Convert.ToDecimal(txtPLLimPreferencia.Text);
break;
case 6:
//Gaussiano
item.valorDefault = Convert.ToDecimal(txtGSigma.Text);
break;
default:
break;
}
}
return entidad;
}
