private function return_array_children($id)
{
$indicadorBean = IndicatorsScPeer::retrieveByPK($id);
if (is_object($indicadorBean)) {
$criterio_indicadores = new Criteria();
$criterio_indicadores->add(IndicatorsScPeer::FLAG, '%habilitado%', Criteria::LIKE);
$criterio_indicadores->add(IndicatorsScPeer::PARENTS, '%p' . $indicadorBean->getId() . 's%', Criteria::LIKE);
$lista_indicadores = IndicatorsScPeer::doSelect($criterio_indicadores);
if (count($lista_indicadores) > 0) {
return $lista_indicadores;
} else {
return null;
}
} else {
return null;
}
}
public function return_name_indicators_by_id($id)
{
$indicators = IndicatorsScPeer::retrieveByPK($id);
if ($indicators > 0) {
return $indicators->getName();
} else {
return "Desconocido";
}
}
public function executeSave_indicator(sfWebRequest $request)
{
$request->setRequestFormat('json');
$indicadorId = $request->getParameter('indicatorId');
$titulo = $request->getParameter('title');
$descripcion = $request->getParameter('description');
$valor_minimo = $request->getParameter('valueMin');
$valor_deseado = $request->getParameter('valueDes');
$valor_optimo = $request->getParameter('valueOpt');
$responsable_id = $request->getParameter('responsableId');
$responsable_email = $request->getParameter('responsableEmail');
$grupo_trabajo_id = $request->getParameter('workGroup');
$json_children = $request->getParameter('indicatorChildren');
$json = json_decode($json_children);
if (count($json) > 0) {
foreach ($json as $row) {
$indicador_children = IndicatorsScPeer::retrieveByPK($row->{'pk'});
$indicador_children->setConectoresConfigure($row->{'values'});
$indicador_children->save();
}
}
//primero validamos y esta logeado
//segundo validamos si el idicador existe
//tercero verificamos si se asigno un usuario
//(si se le asigno un usuario)cuarto vamos a revisar si el usuario que es asignado esta en e grupo de trabajo
/*si no esta en grupo de trabajo envio una solictud ( antes verifico si no le mande una solicitud antes)
* por que no se va estar mandando varias solicitudes al mismo usuario
* en este caso las solicitudes son 1 vez por grupo de trabajo y no por indicador
*/
//despues de vefiricar grabamos la primera vesion del indicador con los datos secundarios
$user = $this->getUser()->getAttribute(sfConfig::get('app_session_current_user'), null);
if ($user != null) {
$indicador = IndicatorsScPeer::retrieveByPK($indicadorId);
if (is_object($indicador)) {
if ($responsable_email != "") {
/* aca vamos crear el registro de asignaciones, esta tabla me permite manejar un
historial de las asignacion de resposanble x indicador
asi podre ver todas los responsables de un determinado indicador.*/
$asignacion_indicador = new AsignacionSc();
$asignacion_indicador->setGrupoId($grupo_trabajo_id);
$asignacion_indicador->setEmail($responsable_email);
$asignacion_indicador->setTreeId($indicador->getTreeId());
$asignacion_indicador->setIndicadorId($indicador->getId());
$asignacion_indicador->setCreateAt(time());
$asignacion_indicador->setUpdateAt(time());
/**********************************************************************/
if ($responsable_id != "") {
$asignacion_indicador->setFlag(json_encode(array("estado" => true, "owner_id" => $user->getId())));
$asignacion_indicador->setUserId($responsable_id);
$indicador->setResponsableId($responsable_id);
$indicador->setEmailResponsable($responsable_email);
} else {
//envio solicitud
//antes verificar si no le enviando una solicitud antes
$rsp = $this->evaluar_solicitud($responsable_email, $grupo_trabajo_id, $user);
if ($rsp['success']) {
$indicador->setEmailResponsable($responsable_email);
$indicador->setResponsableId(null);
$asignacion_indicador->setFlag(json_encode(array("estado" => false, "owner_id" => $user->getId())));
} else {
$this->message = $rsp['message'];
return sfView::ERROR;
}
}
$asignacion_indicador->save();
} else {
$indicador->setResponsableId(null);
$indicador->setEmailResponsable('');
}
if ($descripcion != "") {
$indicador->setDescripcion($descripcion);
}
if ($valor_minimo != "") {
$indicador->setValorMinimo($valor_minimo);
}
if ($valor_deseado != "") {
$indicador->setValorDeseado($valor_deseado);
}
if ($valor_optimo != "") {
$indicador->setValorOptimo($valor_optimo);
}
if ($titulo != "") {
$indicador->setTitulo($titulo);
}
$indicador->save();
} else {
$this->message = 'not found indicator';
return sfView::ERROR;
}
} else {
$this->message = 'session expired';
return sfView::ERROR;
}
}
public function executeAjax_show_gauge_indicators(sfWebRequest $request)
{
$id = $request->getParameter('id_indicators');
//busco el id del indicador
$indicador = IndicatorsScPeer::retrieveByPK($id);
$this->nombre = $indicador->getTitulo();
$minimo = $indicador->getValorMinimo();
$optimo = $indicador->getValorOptimo();
$deseado = $indicador->getValorDeseado();
$valor_actual = $indicador->getValorActualEntregado();
if ($valor_actual != null) {
$divisor = $optimo - $minimo;
if ($valor_actual <= $minimo) {
$valor_porcentaje = 0;
} else {
$dividendo = $valor_actual - $minimo;
$valor_porcentaje = $dividendo * 100 / $divisor;
}
$this->valor_porcentaje = $valor_porcentaje;
//para mostrar
$this->minimo = $minimo;
$this->optimo = $optimo;
$this->deseado = $deseado;
$this->actual = $valor_actual;
} else {
$this->valor_porcentaje = null;
//para mostrar
$this->minimo = $minimo;
$this->optimo = $optimo;
$this->deseado = $deseado;
$this->actual = null;
}
}
public function getTipoConector($nodo_id)
{
$indicador = IndicatorsScPeer::retrieveByPK($nodo_id);
if ($indicador->getDetNetworkAttributeId() != null) {
$resp = $indicador->getDetNetworkAttribute()->getNetwork()->getName();
} else {
$resp = "Manual";
}
return $resp;
}
public function executeOauthcallback(sfWebRequest $request)
{
$code = $request->getParameter('code');
$state = $request->getParameter('state');
/* indicador_id */
$handle_error = $request->getParameter('error');
$indicator = IndicatorsScPeer::retrieveByPK($state);
$id_tree = $indicator->getTreeId();
$current_user = $this->getUser()->getAttribute(sfConfig::get('app_session_current_user'));
$c = new Criteria();
$c->add(UserGoogleConfigurationPeer::USER_ID, $current_user->getId());
$google_configuration = UserGoogleConfigurationPeer::doSelectOne($c);
if (!is_object($google_configuration)) {
$this->getUser()->setFlash('msg', 'Primero debes configurar los datos de tu cuenta Google');
$this->redirect('@configuration');
}
$google_client_id = $google_configuration->getGoogleClientId();
$google_client_secret = $google_configuration->getGoogleClientSecret();
if ($handle_error == 'access_denied') {
//$this->getUser()->setFlash('message','Oops, ha ocurrido un error. Intenta nuevamente.');
return $this->redirect('@edit_strategy?id_tree=' . $id_tree . '&node_id=' . $indicator->getId() . '&response=error&from=g');
} else {
if ($code != '' && $state != '') {
$postdata = http_build_query(array('code' => $code, 'client_id' => $google_client_id, 'client_secret' => $google_client_secret, 'redirect_uri' => $this->getController()->genUrl('@oauthcallback', true), 'grant_type' => 'authorization_code'));
$opts = array('http' => array('method' => 'POST', 'header' => "Content-type: application/x-www-form-urlencoded\r\n", 'content' => $postdata));
$context = stream_context_create($opts);
$result = @file_get_contents('https://accounts.google.com/o/oauth2/token', false, $context);
if ($result === FALSE) {
$this->getUser()->setFlash('msg', 'Configurar correctamente');
$this->redirect('@configuration');
} else {
$json = json_decode($result);
//consultamos el email del usuario, para adjuntarlo al registro
$userinfo = @file_get_contents('https://www.googleapis.com/oauth2/v1/userinfo?access_token=' . $json->{'access_token'});
$json_userinfo = json_decode($userinfo);
if ($userinfo === FALSE) {
$this->redirect('@edit_strategy?id_tree=' . $id_tree . '&node_id=' . $indicator->getId() . '&response=error&from=g');
} else {
/* si $json->{'refresh_token'} devuelve nada, es porque anteriormente ya permitió el acceso */
if (isset($json->{'refresh_token'})) {
//primera vez que pide permiso de acceso
//si existe el refresh_token, se reemplaza, ya que es porque anteriormente ha revocado el permiso de acceso
$c = new Criteria();
$c->add(IndicadoresScGoogleAnalyticsPeer::GOOGLE_USER_EMAIL, $json_userinfo->{'email'});
$c->add(IndicadoresScGoogleAnalyticsPeer::INDICADOR_ID, $indicator->getId());
$indicadores_sc_google_analytics_object = IndicadoresScGoogleAnalyticsPeer::doSelectOne($c);
if (is_object($indicadores_sc_google_analytics_object)) {
//obtener nodos "del arbol $id_tree" del mismo google_user_email
$c = new Criteria();
//$c->add(IndicatorsScPeer::TREE_ID, $id_tree);
$c->add(IndicatorsScPeer::FLAG, 'habilitado');
$c->add(IndicatorsScPeer::ULTIMO_NODO, 1);
$c->add(IndicatorsScPeer::DET_NETWORK_ATTRIBUTE_ID, null, Criteria::NOT_EQUAL);
$c->add(IndicadoresScGoogleAnalyticsPeer::GOOGLE_USER_EMAIL, $json_userinfo->{'email'});
$c->addJoin(IndicadoresScGoogleAnalyticsPeer::INDICADOR_ID, IndicatorsScPeer::ID);
$lista_nodos = IndicatorsScPeer::doSelect($c);
//obtener nodos con conector exterior pertenecientes al usuario $json_userinfo->{'email'}
foreach ($lista_nodos as $row) {
//actualizar su refresh_token
$c = new Criteria();
$c->add(IndicadoresScGoogleAnalyticsPeer::INDICADOR_ID, $row->getId());
$temp = IndicadoresScGoogleAnalyticsPeer::doSelectOne($c);
$temp->setRefreshToken($json->{'refresh_token'});
$temp->save();
}
} else {
//sino, se crea
$indicadores_sc_google_analytics = new IndicadoresScGoogleAnalytics();
$indicadores_sc_google_analytics->setRefreshToken($json->{'refresh_token'});
$indicadores_sc_google_analytics->setGoogleUserEmail($json_userinfo->{'email'});
$indicadores_sc_google_analytics->setIndicadorId($indicator->getId());
$indicadores_sc_google_analytics->save();
}
$this->redirect('@edit_strategy?id_tree=' . $id_tree . '&node_id=' . $indicator->getId() . '&response=success&from=g');
} else {
//buscar los nodos del mismo arbol
$c = new Criteria();
$c->add(IndicadoresScGoogleAnalyticsPeer::GOOGLE_USER_EMAIL, $json_userinfo->{'email'});
//$c->add(IndicatorsScPeer::TREE_ID, $indicator->getTreeId());//puede ser del mismo arbol u otro
$c->add(IndicatorsScPeer::FLAG, 'habilitado');
$c->addJoin(IndicadoresScGoogleAnalyticsPeer::INDICADOR_ID, IndicatorsScPeer::ID);
$object = IndicadoresScGoogleAnalyticsPeer::doSelectOne($c);
if (is_object($object)) {
$indicadores_sc_google_analytics = new IndicadoresScGoogleAnalytics();
$indicadores_sc_google_analytics->setRefreshToken($object->getRefreshToken());
$indicadores_sc_google_analytics->setGoogleUserEmail($json_userinfo->{'email'});
$indicadores_sc_google_analytics->setIndicadorId($indicator->getId());
$indicadores_sc_google_analytics->save();
}
$this->redirect('@edit_strategy?id_tree=' . $id_tree . '&node_id=' . $indicator->getId() . '&response=success&from=g');
}
}
}
}
}
}
private function recalcular($nodo)
{
$suma_hijos = 0;
$hijos_del_padre = $this->get_hijos($nodo->getPreviousId());
if ($hijos_del_padre != null) {
foreach ($hijos_del_padre as $row) {
$valor_actual = $row->getValorActualEntregado();
$valor_porcentual = $row->getConectoresConfigure();
$valor_minimo = $row->getValorMinimo();
$valor_maximo = $row->getValorOptimo();
$division = $valor_actual / $valor_maximo;
if ($this->soy_padre($row)) {
$valor_minimo = 0;
}
if ($valor_actual <= $valor_minimo) {
$division = 0;
} else {
if ($division >= 1) {
$suma_hijos = $suma_hijos + $valor_porcentual / 100;
} else {
$suma_hijos = $suma_hijos + $valor_actual * ($valor_porcentual / 100) / $valor_maximo;
}
}
}
$padre = IndicatorsScPeer::retrieveByPK($nodo->getPreviousId());
$valor_final = $suma_hijos * 100;
$padre->setValorActualEntregado($valor_final);
$padre->save();
$this->validar_si_tiene_padre($padre);
}
}
public function executeDelete_indicador(sfWebRequest $request)
{
$indicator = $request->getParameter('indicator');
$user = $this->getUser()->getAttribute(sfConfig::get('app_session_current_user'), null);
if ($user != null) {
try {
$conn = Propel::getConnection();
$conn->beginTransaction();
$indicadorBean = IndicatorsScPeer::retrieveByPK($indicator);
if (is_object($indicadorBean)) {
$id_tree = $indicadorBean->getTreeId();
$criterio_indicadores = new Criteria();
$criterio_indicadores->add(IndicatorsScPeer::PARENTS, '%p' . $indicadorBean->getId() . 's%', Criteria::LIKE);
$criterio_update = new Criteria();
$criterio_update->add(IndicatorsScPeer::FLAG, 'eliminado');
BasePeer::doUpdate($criterio_indicadores, $criterio_update, $conn);
//antes de eliminar el indicador vamos a revisar si el indicador antesesor
//seria el ultimo nodo y asi cambiarle su estado de ultimo_nodo a true
/*aca reviso si hay indicadores que todovia dependan del anterior indicador*/
$criterio_set_estado = new Criteria();
$criterio_set_estado->add(IndicatorsScPeer::PREVIOUS_ID, $indicadorBean->getPreviousId());
/*si es asi entonces no cambio nada encambio si no hay ninguno entonces quiere decir
* que ese indicador quedaria como ultimo y entonces tendria que cambiarle el estado */
$cantidad_de_registros = IndicatorsScPeer::doCount($criterio_set_estado);
/* menor igual 1 por que por logica por lo menos me va botar 1 resultado esta
* consulta (por el indicador actual)
*/
if ($cantidad_de_registros <= 1) {
$indicador_update = IndicatorsScPeer::retrieveByPK($indicadorBean->getPreviousId());
$indicador_update->setUltimoNodo(true);
$indicador_update->save();
}
$indicadorBean->setFlag('eliminado');
$indicadorBean->save();
$conn->commit();
/*Despues de eliminar el o los nodos vamos a enviar nuevamente el arbol y
* sus indicadores (nodos) para que se arme nuevamente.
*/
$criterio = new Criteria();
$criterio->add(TreeScPeer::USER_ID, $user->getId());
$criterio->add(TreeScPeer::ID, $id_tree);
$tree = TreeScPeer::doSelectOne($criterio);
$criterio->clear();
if (is_object($tree)) {
$criterio->add(IndicatorsScPeer::FLAG, '%habilitado%', Criteria::LIKE);
$criterio->add(IndicatorsScPeer::TREE_ID, $tree->getId());
$criterio->addAscendingOrderByColumn(IndicatorsScPeer::PREVIOUS_ID);
$list_indicadores_send = IndicatorsScPeer::doSelect($criterio);
$this->lista_indicadores = $list_indicadores_send;
$this->tree = $tree;
}
$conn = Propel::close();
return sfView::SUCCESS;
} else {
$this->message = 'el indicador no existe';
$conn = Propel::close();
return sfView::ERROR;
}
} catch (Exception $e) {
$conn = Propel::close();
return sfView::ERROR;
}
} else {
$this->message = 'session expired';
$conn = Propel::close();
return sfView::ERROR;
}
}
public function current_color_production($indicator_id, $array_color)
{
$indicator = IndicatorsScPeer::retrieveByPK($indicator_id);
$valor_minimo = $indicator->getValorMinimo();
$valor_desaado = $indicator->getValorDeseado();
$valor_optimo = $indicator->getValorOptimo();
$valor_actual = $indicator->getValorActualEntregado();
if ($valor_actual >= $valor_desaado) {
return $array_color[0];
} elseif ($valor_actual >= $valor_minimo) {
return $array_color[1];
} else {
return $array_color[2];
}
}
