protected function generar_elementos($id_item)
{
//--- Carga el item acual
$item = new toba_item_molde($this);
$item->cargar($id_item);
//--- Clona el ci actual
$datos_destino = $this->dr_molde->tabla('molde')->get();
$datos_origen = $this->dr_molde->tabla('base')->get();
$id_origen = array();
$id_origen['proyecto'] = $datos_origen['origen_proyecto'];
$id_origen['componente'] = $datos_origen['origen_item'];
$item_origen = toba_constructor::get_info($id_origen, 'toba_item');
$opciones = array();
$opciones['proyecto'] = $this->id_molde_proyecto;
$opciones['fuente_datos'] = $datos_destino['fuente'];
$opciones['fuente_datos_proyecto'] = $this->id_molde_proyecto;
if (isset($datos_destino['punto_montaje'])) {
$opciones['punto_montaje'] = $datos_destino['punto_montaje'];
$item->set_punto_montaje($datos_destino['punto_montaje']);
}
foreach ($item_origen->get_hijos() as $hijo) {
$id_nuevo_hijo = $hijo->clonar($opciones, $datos_destino['carpeta_archivos'], false);
$item->asociar_objeto($id_nuevo_hijo['componente']);
}
//-- Genera el item
$item->generar();
$this->generar_archivos_consultas();
$this->guardar_log_elementos_generados();
}
function generar_html_barra_vinculos()
{
if ($this->editable_info['molde'] || $this->editable_info['componentes'] == 0) {
$vinculo = toba::vinculador()->get_url(toba_editor::get_id(), 1000110, null, array('zona' => true, 'validar' => false, 'menu' => 1));
echo '<a href="' . $vinculo . '">' . toba_recurso::imagen_toba('wizard.png', true, null, null, 'Asistente para la generación de Operaciones');
if ($this->editable_info['molde']) {
echo $this->editable_info['molde_tipo_operacion_nombre'];
}
echo "</a>\n";
}
//Acceso al EDITOR PHP
if ($this->editable_info['actividad_accion'] != '') {
$componente = $this->get_editable();
$id = array('proyecto' => $componente[0], 'componente' => $componente[1]);
$info = toba_constructor::get_info($id, 'toba_item');
// Ir al editor
$ver = $info->get_utileria_editor_ver_php();
echo "<a href='" . $ver['vinculo'] . "'>" . toba_recurso::imagen($ver['imagen'], null, null, $ver['ayuda']) . "</a>\n";
// Apertura del archivo
if (admin_util::existe_archivo_subclase($this->editable_info['actividad_accion'])) {
$abrir = $info->get_utileria_editor_abrir_php();
echo '<a href="' . $abrir['vinculo'] . '">' . toba_recurso::imagen($abrir['imagen'], null, null, $abrir['ayuda']) . "</a>\n";
}
}
parent::generar_html_barra_vinculos();
}
function probar_item($id, $anexo, $clonar_archivos = false)
{
$info = toba_constructor::get_info(array('componente' => $id, 'proyecto' => 'toba_testing'), 'toba_item');
$clon = $info->clonar($anexo, $clonar_archivos, false);
$this->assertTrue(is_numeric($clon['item']));
$this->assertNotEqual($clon['item'], $id);
//--- Verificación
return toba_constructor::get_info(array('proyecto' => $clon['proyecto'], 'componente' => $clon['item']), 'toba_item');
}
static function redireccionar_a_editor_objeto($proyecto, $objeto)
{
$clave = array('componente' => $objeto, 'proyecto' => $proyecto);
$vinculo = toba_constructor::get_info($clave)->vinculo_editor();
admin_util::refrescar_editor_item();
echo toba_js::abrir();
echo "window.location.href='{$vinculo}'\n";
echo toba_js::cerrar();
}
function test_eventos_ci_con_dependencias()
{
//Un formulario como dependencia que no tiene el 'baja' entre los predefinidos
$predefinidos = array('evt__formulario__carga', 'evt__formulario__alta', 'evt__formulario__modificacion', 'evt__formulario__cancelar', 'evt__cuadro__carga', 'evt__cuadro__seleccion', 'evt__filtro__filtrar', 'evt__filtro__cancelar');
$desconocidos = array('evt__formulario__observar', 'evt__formulario__baja', 'evt__cuadro__baja');
$sospechosos = array('evt__formulario___otro', 'evt__formulario_alta', 'evt__filtro_cantar');
$et_ci = toba_constructor::get_info(array('proyecto' => 'toba_testing', 'componente' => 1323));
$this->asertar_eventos($et_ci, $predefinidos, array(), $desconocidos, $sospechosos);
}
function cargar($opciones, $id_item_inicial = null, $incluidos_forzados = array())
{
if (!isset($id_item_inicial)) {
$id_item_inicial = toba_info_editores::get_item_raiz($this->proyecto);
}
$en_profundidad = $this->debe_cargar_en_profundidad($id_item_inicial, $opciones);
$filtro_items = "";
if (!$this->debe_cargar_todo($opciones) || $en_profundidad) {
//--- Se dejan solo los items del primer nivel, excepto que este en las excepciones
if (isset($id_item_inicial)) {
$id_item_sano = toba_contexto_info::get_db()->quote($id_item_inicial);
$filtro_padre = "(i.padre = {$id_item_sano} OR i.item= {$id_item_sano})";
//OR i.padre IN (SELECT item FROM apex_item WHERE padre='$id_item_inicial'))";
}
if (!empty($incluidos_forzados) && !$en_profundidad) {
$forzados = implode("', '", $incluidos_forzados);
$filtro_incluidos = "( i.padre IN ('" . $forzados . "')";
$filtro_incluidos .= " OR i.item IN ('" . $forzados . "') )";
}
if (isset($filtro_padre) && isset($filtro_incluidos)) {
$filtro_items = "\tAND ({$filtro_padre} \n\t\t\t\t\t\t\t\t\t\tOR \n\t\t\t\t\t\t\t\t\t{$filtro_incluidos})\n\t\t\t\t\t";
} elseif (isset($filtro_padre)) {
$filtro_items = "\tAND {$filtro_padre} ";
} elseif (isset($filtro_incluidos)) {
$filtro_items = "\tAND {$filtro_incluidos} ";
}
}
if (isset($opciones['solo_carpetas']) && $opciones['solo_carpetas'] == 1) {
$filtro_items .= "\tAND i.carpeta = 1";
}
//-- Se utiliza como sql básica aquella que brinda la definición de un componente
toba_item_def::set_db(toba_contexto_info::get_db());
$sql_base = toba_item_def::get_vista_extendida($this->proyecto);
$sql = sql_concatenar_where($sql_base['basica']['sql'], array(" (i.solicitud_tipo IS NULL OR i.solicitud_tipo <> 'fantasma')" . $filtro_items));
$sql = sql_agregar_ordenamiento($sql, array(array('i.carpeta', 'asc'), array('i.orden', 'asc'), array('i.nombre', 'asc')));
$rs = toba_contexto_info::get_db()->consultar($sql);
$this->items = array();
if (!empty($rs)) {
foreach ($rs as $fila) {
$id = array();
$id['componente'] = $fila['item'];
$id['proyecto'] = $fila['item_proyecto'];
$datos = array('basica' => $fila);
if ($en_profundidad) {
$info = toba_constructor::get_info($id, 'toba_item', true, null, true, true);
} else {
$info = toba_constructor::get_info($id, 'toba_item', false, $datos);
}
$this->items[$fila['item']] = $info;
}
$this->carpeta_inicial = $id_item_inicial;
$this->mensaje = "";
$this->ordenar();
$this->filtrar($opciones);
}
}
function test_otorgar_permiso()
{
//Se carga un item sin permisos
$item = toba_constructor::get_info(array('proyecto' => 'toba_testing', 'componente' => 1000221), 'toba_item');
//Se le asigna permisos al documentador en el proyecto de testing
$item->otorgar_permiso('documentacion');
//Se vuelve a cargar debe tener permisos de documentador
$item = toba_constructor::get_info(array('proyecto' => 'toba_testing', 'componente' => 1000221), 'toba_item');
$this->AssertEqual(count($item->grupos_acceso()), 1, 'Debe haber sólo 1 grupo (%s)');
$this->AssertTrue($item->grupo_tiene_permiso('documentacion'), 'Documentacion tiene derechos sobre el item');
}
function probar_objeto($id)
{
$nuevo_nombre = "Objeto Clonado";
$nuevos_datos = array('nombre' => $nuevo_nombre);
$info = toba_constructor::get_info(array('componente' => $id, 'proyecto' => 'toba_testing'));
$clon = $info->clonar($nuevos_datos, false);
//--- Verificación
$meta_objeto = toba_constructor::get_info(array('proyecto' => $clon['proyecto'], 'componente' => $clon['objeto']));
$this->assertEqual($nuevo_nombre, $meta_objeto->get_nombre_largo());
$this->assertTrue(is_numeric($clon['objeto']));
$this->assertNotEqual($clon['objeto'], $id);
}
function __construct($asistente)
{
$this->id = $this->asistente->get_id_elemento();
$this->proyecto = $this->asistente->get_proyecto();
//Busco el datos relacion correspondientes al componente
$id = toba_info_editores::get_dr_de_clase($this->clase);
$componente = array('proyecto' => $id[0], 'componente' => $id[1]);
$this->datos = toba_constructor::get_runtime($componente);
$this->datos->inicializar();
$datos = array('nombre' => $this->clase . ' generado automaticamente', 'proyecto' => $this->proyecto);
$this->ini();
}
function __wakeup()
{
foreach ($this->_propiedades_toba as $tipo => $props) {
foreach ($props as $prop) {
if ($tipo == 'componente') {
$valor = $this->{$prop};
$id = array('componente' => $valor[1], 'proyecto' => $valor[0]);
$this->{$prop} = toba_constructor::buscar_runtime($id);
}
}
}
}
/**
* Similar al anterior pero se dispara un evento seleccion e implicitamente
* tambien el evento modificacion
*/
function crear_ml_para_seleccion($observador, $metodo, $datos, $parametros, $evento = 'seleccion')
{
$ml = toba_constructor::get_runtime(array('proyecto' => 'toba_testing', 'componente' => '1322'), 'toba_ei_formulario_ml');
$ml->inicializar(array('nombre_formulario' => ''));
$ml->agregar_controlador($observador);
$ml->set_metodo_analisis($metodo);
$_POST['ei_form1322'] = $evento;
$_POST['objeto_form_1322__parametros'] = "{$parametros}";
$_POST['objeto_form_1322_listafilas'] = implode('_', array_keys($datos));
//Seteo los efs
foreach ($datos as $id => $valor) {
$_POST["1322lista{$id}"] = $valor['lista'];
}
$ml->disparar_eventos();
}
/**
* Se le asigna un objeto a una pantalla de un ci que ya tenia un objeto
*/
function test_asignar_a_pantalla_ci_con_objetos_previos()
{
//Setup, se le asigna a una pantalla que ya tiene un objeto
$ci_destino = array('tipo' => 'toba_ci_pantalla', 'objeto' => '1605', 'proyecto' => 'toba_testing', 'id_dependencia' => 'el_ci', 'pantalla' => '960');
//Test
$asignador = new asignador_objetos($this->objeto_creado, $ci_destino);
$asignador->asignar();
//Validacion
$obj = toba_constructor::get_info(array('proyecto' => 'toba_testing', 'componente' => '1605'), 'toba_ci');
$hijos = $obj->get_hijos();
$this->assertEqual(count($obj->get_hijos()), 2);
//Tiene dos pantallas
$pantalla = $hijos[0];
$this->assertEqual($pantalla->get_id(), 'pantalla1');
$this->assertEqual(count($pantalla->get_hijos()), 2);
}
function __construct($asistente)
{
$this->asistente = $asistente;
$this->asistente->registrar_molde($this);
$this->id = $this->asistente->get_id_elemento();
$this->proyecto = $this->asistente->get_proyecto();
//Busco el datos relacion correspondientes al componente
$id = toba_info_editores::get_dr_de_clase($this->clase);
$componente = array('proyecto' => $id[0], 'componente' => $id[1]);
$this->datos = toba_constructor::get_runtime($componente);
$this->datos->inicializar();
$datos = array('nombre' => $this->clase . ' generado automaticamente', 'proyecto' => $this->proyecto);
if ($this->asistente->tiene_fuente_definida()) {
$datos['fuente_datos_proyecto'] = $this->proyecto;
$datos['fuente_datos'] = $this->asistente->get_fuente();
}
$this->datos->tabla('base')->set($datos);
$this->ini();
}
function get_hijos()
{
// Un CN que esta asociado no muestra recursivamente sus asociaciones (puede haber relaciones circulares)
// El codigo se pone aca porque tiene que ser ejecutado despues del constructor para que el flag tenga efecto
// ... y esta es la unica ventana cuya ejecucion esta garantizada
if (!$this->cn_asociado) {
if (isset($this->datos['_info_consumo']) && count($this->datos['_info_consumo']) > 0) {
$cantidad_subelementos = count($this->subelementos);
for ($a = 0; $a < count($this->datos['_info_consumo']); $a++) {
$clave['proyecto'] = $this->datos['_info_consumo'][$a]['proyecto'];
$clave['componente'] = $this->datos['_info_consumo'][$a]['objeto'];
$tipo = $this->datos['_info_consumo'][$a]['clase'];
$id = $cantidad_subelementos + $a;
$this->subelementos[$id] = toba_constructor::get_info($clave, $tipo, $this->carga_profundidad, null, true, $this->datos_resumidos);
$this->subelementos[$id]->set_consumidor($this, $this->datos['_info_consumo'][$a]);
$this->subelementos[$id]->set_asociado();
}
}
}
return $this->subelementos;
}
function evt__procesar()
{
list($proyecto_actual, $item_actual) = toba::zona()->get_editable();
$id = array('proyecto' => $proyecto_actual, 'componente' => $item_actual);
$info_item = toba_constructor::get_info($id, 'toba_item');
$directorio = false;
if ($this->opciones['con_subclases']) {
$directorio = $this->opciones['carpeta_subclases'];
}
$nuevos_datos = array();
$nuevos_datos['proyecto'] = $this->opciones['proyecto'];
$nuevos_datos['padre_proyecto'] = $this->opciones['proyecto'];
$nuevos_datos['padre'] = $this->opciones['carpeta'];
$nuevos_datos['punto_montaje'] = $this->opciones['punto_montaje'];
$nuevos_datos['pagina_tipo_proyecto'] = $this->opciones['pagina_tipo_proyecto'];
$nuevos_datos['pagina_tipo'] = $this->opciones['pagina_tipo'];
if (isset($this->opciones['anexo'])) {
$nuevos_datos['anexo_nombre'] = $this->opciones['anexo'];
}
$nuevos_datos['fuente_datos'] = $this->opciones['fuente'];
$nuevos_datos['fuente_datos_proyecto'] = $this->opciones['proyecto'];
$info_item->clonar($nuevos_datos, $directorio);
toba::notificacion()->info('Clonado OK');
}
function pre_run()
{
toba_constructor::set_refresco_forzado(true);
}
function get_nombre_destino()
{
$clave = array('componente' => $this->destino['objeto'], 'proyecto' => $this->destino['proyecto']);
$nombre = '';
if (isset($this->destino)) {
switch ($this->destino['tipo']) {
case 'toba_item':
case 'toba_ci':
case 'toba_datos_relacion':
$info = toba_constructor::get_info($clave, $this->destino['tipo'], false);
$nombre .= $info->get_nombre_corto();
break;
case 'toba_ci_pantalla':
//--- Si es una pantalla el info_ci se carga en profunidad para traer el nombre de la misma
$info = toba_constructor::get_info($clave, 'toba_ci', true);
$nombre .= $info->get_nombre_corto();
break;
}
}
return $nombre;
}
function post_eventos()
{
if ($this->disparar_importacion_columnas) {
if (isset($this->s__importacion_cols['datos_tabla'])) {
$clave = array('proyecto' => toba_editor::get_proyecto_cargado(), 'componente' => $this->s__importacion_cols['datos_tabla']);
$dt = toba_constructor::get_info($clave, 'toba_datos_tabla');
$this->s__importacion_cols = $dt->exportar_datos_columnas($this->s__importacion_cols['pk']);
//ei_arbol($this->s__importacion_cols);
$cols = $this->get_entidad()->tabla('columnas');
foreach ($this->s__importacion_cols as $col) {
try {
$cols->nueva_fila($col);
} catch (toba_error $e) {
toba::notificacion()->agregar("Error agregando la columna '{$col['clave']}'. " . $e->getMessage());
}
}
}
$this->disparar_importacion_columnas = false;
}
}
protected function usar_metodo_dt($param_dt, $parametros, $es_carga_inicial = false)
{
//Elijo el metodo de carga dependiendo de si es masiva o no.
if ($es_carga_inicial && isset($parametros['permite_carga_masiva']) && $parametros['permite_carga_masiva'] == '1') {
$nombre_metodo = $parametros['metodo_masivo'];
} else {
$nombre_metodo = $parametros['metodo'];
}
$id = array('proyecto' => toba::proyecto()->get_id(), 'componente' => $parametros['tabla']);
$dt = toba_constructor::get_runtime($id, 'toba_datos_tabla');
if (!method_exists($dt, $nombre_metodo)) {
$clase = get_class($dt);
$this->log("ERROR en la carga de una columna externa. No existe el método '{$nombre_metodo}' de la clase '{$clase}'");
throw new toba_error_def("AP_TABLA_DB: ERROR en la carga de una columna externa. No existe el método '{$nombre_metodo}' de la clase '{$clase}'");
}
$datos = call_user_func_array(array($dt, $nombre_metodo), $param_dt);
return $datos;
}
function evt__procesar()
{
abrir_transaccion('instancia');
$directorio = false;
if ($this->datos['con_subclases']) {
$directorio = $this->datos['carpeta_subclases'];
}
list($proyecto_actual, $comp_actual) = toba::zona()->get_editable();
$id = array('proyecto' => $proyecto_actual, 'componente' => $comp_actual);
$info = toba_constructor::get_info($id, null, $this->datos['profundidad']);
$nuevos_datos = array('anexo_nombre' => $this->datos['anexo_nombre']);
$clon = $info->clonar($nuevos_datos, $directorio, false);
//--- Asignación
if (isset($this->destino)) {
$asignador = new asignador_objetos($clon, $this->destino);
$asignador->asignar();
}
cerrar_transaccion('instancia');
admin_util::redireccionar_a_editor_objeto($clon['proyecto'], $clon['objeto']);
}
function get_dr()
{
$dr = toba_constructor::get_runtime(array('proyecto' => 'toba_testing', 'componente' => '1516'), 'toba_datos_relacion');
$dr->inicializar();
return $dr;
}
/**
* Construye una dependencia y la asocia al componente actual
*
* @param unknown_type $identificador
* @param unknown_type $parametros
* @return unknown
* @ignore
*/
function cargar_dependencia($identificador)
{
if (!isset($this->_indice_dependencias[$identificador])) {
throw new toba_error_def("OBJETO [cargar_dependencia]: No EXISTE una dependencia asociada al indice [{$identificador}].");
}
$posicion = $this->_indice_dependencias[$identificador];
$clase = $this->_info_dependencias[$posicion]['clase'];
$clave['proyecto'] = $this->_info_dependencias[$posicion]['proyecto'];
$clave['componente'] = $this->_info_dependencias[$posicion]['objeto'];
$this->_dependencias[$identificador] = toba_constructor::get_runtime($clave, $clase);
}
function evt__form_nombre__modificacion($datos)
{
$this->s__datos_nombre = $datos;
//-- Sincroniza el cambio con la base
$path_relativo = $this->get_path_relativo();
if ($path_relativo != '') {
$path_relativo .= '/';
}
$datos['subclase_archivo'] = $path_relativo . $this->s__datos_nombre['nombre'] . '.php';
$pm = $this->recuperar_punto_montaje();
$this->get_metaclase()->set_subclase($this->s__datos_nombre['nombre'], $datos['subclase_archivo'], $pm->get_id());
toba_constructor::set_refresco_forzado(true);
}
/**
* Carga la SOLICITUD actual. Se determina el item y se controla el acceso al mismo
*/
function cargar_solicitud_web()
{
if (toba::manejador_sesiones()->existe_sesion_activa()) {
// Estoy dentro de una SESION
$item = $this->get_id_item('item_inicio_sesion', false, true);
if (!$item[0] || !$item[1]) {
throw new toba_error_def('ERROR: No esta definido el ITEM de INICIO de sesion');
}
$this->iniciar_contexto_solicitud($item);
$solicitud = toba_constructor::get_runtime(array('proyecto' => $item[0], 'componente' => $item[1]), 'toba_item');
if (!$solicitud->es_item_publico()) {
$this->autorizar_acceso_item($item);
}
return $solicitud;
} else {
// Estoy fuera de la sesion. Solo se puede acceder a lo publico
$mensaje_error = 'La sesión no esta activa. Solo es posible acceder items PUBLICOS.';
$item = $this->get_id_item('item_pre_sesion');
if (!$item[0] || !$item[1]) {
throw new toba_error_def('ERROR: No esta definido el ITEM de LOGIN');
}
$this->iniciar_contexto_solicitud($item);
$solicitud = toba_constructor::get_runtime(array('proyecto' => $item[0], 'componente' => $item[1]), 'toba_item');
if (!$solicitud->es_item_publico()) {
// Si se arrastra una URL previa despues de finalizar la sesion y se refresca la pagina
// el nucleo trata de cargar un item explicito por URL. El mismo no va a ser publico...
// Esto apunta a solucionar ese error: Blanqueo el item solicitado y vuelvo a intentar.
// (NOTA: esto puede ocultar la navegacion entre items supuestamente publicos)
if (toba::memoria()->get_item_solicitado()) {
toba::logger()->notice('Fallo la carga de una operación publica. Se intenta con la operación predeterminada', 'toba');
toba::memoria()->set_item_solicitado(null);
$item = $this->get_id_item('item_pre_sesion');
$this->iniciar_contexto_solicitud($item);
$solicitud = toba_constructor::get_runtime(array('proyecto' => $item[0], 'componente' => $item[1]), 'toba_item');
if (!$solicitud->es_item_publico()) {
throw new toba_error_def($mensaje_error);
}
} else {
throw new toba_error_def($mensaje_error);
}
}
return $solicitud;
}
}
/**
* Fuerza a que todos los componentes requeridos en este pedido de página no surjan de algún cache (util para testeos)
*/
static function set_refresco_forzado($refrescar)
{
self::$refresco_forzado = $refrescar;
}
function __wakeup()
{
$id = array('componente' => $this->id_ci[1], 'proyecto' => $this->id_ci[0]);
$this->ci = toba_constructor::buscar_runtime($id);
}
/**
* Duplica un objeto y sus dependencias recursivamente
*
* @param array $nuevos_datos Datos a modificar en la base del objeto. Para anexar algo al nombre se utiliza el campo 'anexo_nombre'
* @param boolean/string $dir_subclases Si el componente tiene subclases clona los archivos, en caso afirmativo indicar la ruta destino (relativa)
* @param boolean $con_transaccion Indica si la clonación se debe incluír en una transaccion
* @return array Clave del objeto que resulta del clonado
*/
function clonar($nuevos_datos, $dir_subclases = false, $con_transaccion = true)
{
//Se busca el id del datos_relacion de la clase
$id_dr = toba_info_editores::get_dr_de_clase($this->datos['_info']['clase']);
//Se construye el objeto datos_relacion
$componente = array('proyecto' => $id_dr[0], 'componente' => $id_dr[1]);
$dr = toba_constructor::get_runtime($componente);
$dr->inicializar();
//Se carga con el id_origen
$dr->cargar(array('proyecto' => $this->proyecto, 'objeto' => $this->id));
foreach ($nuevos_datos as $campo => $valor) {
if ($campo == 'anexo_nombre') {
$campo = 'nombre';
$valor = $valor . $dr->tabla('base')->get_fila_columna(0, $campo);
}
$dr->tabla('base')->set_fila_columna_valor(0, $campo, $valor);
}
//Se le fuerza una inserción a los datos_tabla
//Como la clave de los objetos son secuencias, esto garantiza claves nuevas
$dr->forzar_insercion();
if (!$con_transaccion) {
$dr->persistidor()->desactivar_transaccion();
}
//--- Si tiene subclase, se copia el archivo y se cambia
if ($dir_subclases !== false) {
$proyecto_dest = isset($nuevos_datos['proyecto']) ? $nuevos_datos['proyecto'] : null;
$this->clonar_subclase($dr, $dir_subclases, $proyecto_dest);
}
//--- Se reemplazan los datos y se clonan los hijos
foreach ($this->subelementos as $hijo) {
//-- Si se especifico un proyecto, se propaga
$datos_objeto = array();
if (isset($nuevos_datos['proyecto'])) {
$datos_objeto['proyecto'] = $nuevos_datos['proyecto'];
}
//-- Si se especifica un anexo de nombre, se propaga
if (isset($nuevos_datos['anexo_nombre'])) {
$datos_objeto['anexo_nombre'] = $nuevos_datos['anexo_nombre'];
}
//-- La fuente tambien se propaga
if (isset($nuevos_datos['fuente_datos_proyecto'])) {
$datos_objeto['fuente_datos_proyecto'] = $nuevos_datos['fuente_datos_proyecto'];
}
if (isset($nuevos_datos['fuente_datos'])) {
$datos_objeto['fuente_datos'] = $nuevos_datos['fuente_datos'];
}
//-- Punto de montaje tambien se propaga
if (isset($nuevos_datos['punto_montaje'])) {
$datos_objeto['punto_montaje'] = $nuevos_datos['punto_montaje'];
}
//-- SE CLONA
$id_clon = $hijo->clonar($datos_objeto, $dir_subclases, $con_transaccion);
//--- En el componente actual se reemplaza la dependencia por el clon
$id_fila = $dr->tabla('dependencias')->get_id_fila_condicion(array('identificador' => $hijo->rol_en_consumidor()));
$dr->tabla('dependencias')->modificar_fila(current($id_fila), array('objeto_proveedor' => $id_clon['componente']));
}
//Se intenta acceder a las pantallas/db_registros para pasarle el nuevo punto de montaje
if (isset($nuevos_datos['punto_montaje'])) {
//Trato de setear el punto de montaje para las pantallas
try {
$dr->tabla('pantallas')->set_columna_valor('punto_montaje', $nuevos_datos['punto_montaje']);
} catch (Exception $e) {
}
//Trato de setear el punto de montaje para las propiedades basicas
try {
$dr->tabla('prop_basicas')->set_columna_valor('punto_montaje', $nuevos_datos['punto_montaje']);
} catch (Exception $e) {
}
//Trato de setear el punto de montaje para los efs
try {
$dr->tabla('efs')->set_columna_valor('punto_montaje', $nuevos_datos['punto_montaje']);
} catch (Exception $e) {
}
//Trato de setear el punto de montaje para las columnas del filtro
try {
$dr->tabla('cols')->set_columna_valor('punto_montaje', $nuevos_datos['punto_montaje']);
} catch (Exception $e) {
}
//Trato de setear el punto de montaje para las columnas externas del datos tabla
try {
$dr->tabla('externas')->set_columna_valor('punto_montaje', $nuevos_datos['punto_montaje']);
} catch (Exception $e) {
}
}
$dr->sincronizar();
//Se busca la clave del nuevo objeto
$clave = $dr->tabla('base')->get_clave_valor(0);
$clave['componente'] = $clave['objeto'];
return $clave;
}
/**
* Elimina opcionalmente un conjunto de componentes pertencientes a la operación
*
* @param boolean $borrar_item Debe borrar el item una vez borradas sus dependencias
* @param array $opciones Arreglo 'id_componente' => array('eliminar'=>true/false, 'eliminar_archivo'=>true/false)
* @param boolean $con_transaccion Debe enmarcar la eliminación en una transaccion
*/
function eliminar($borrar_item, $opciones, $con_transaccion = true)
{
$item = toba::zona()->get_info();
$db = toba_contexto_info::get_db();
$arbol_componentes = array_slice($this->arbol, 1);
//--- Se eliminan metadatos
if ($con_transaccion) {
$db->abrir_transaccion();
}
foreach ($arbol_componentes as $comp) {
$opcion = $opciones[$comp['componente']];
if ($opcion['eliminar']) {
//--- Elimina metadatos
$id_dr = toba_info_editores::get_dr_de_clase($comp['tipo']);
$componente = array('proyecto' => $id_dr[0], 'componente' => $id_dr[1]);
$dr = toba_constructor::get_runtime($componente, 'toba_datos_relacion', false);
$dr->inicializar();
$dr->persistidor()->desactivar_transaccion();
$dr->resetear();
$dr->cargar(array('proyecto' => $this->id_proyecto, 'objeto' => $comp['componente']));
$dr->eliminar_todo();
}
}
//--Borro el item
if ($borrar_item) {
$id_dr = toba_info_editores::get_dr_de_clase('toba_item');
$componente = array('proyecto' => $id_dr[0], 'componente' => $id_dr[1]);
$dr = toba_constructor::get_runtime($componente, 'toba_datos_relacion', false);
$dr->inicializar();
$dr->persistidor()->desactivar_transaccion();
$dr->resetear();
$dr->cargar(array('proyecto' => $this->id_proyecto, 'item' => $this->id_item));
$dr->eliminar_todo();
}
if ($con_transaccion) {
$db->cerrar_transaccion();
}
//--- Se eliminan subclases
foreach ($arbol_componentes as $comp) {
$opcion = $opciones[$comp['componente']];
if ($opcion['eliminar'] && $opcion['eliminar_archivo']) {
$archivo = $this->get_path_archivo($comp);
unlink($archivo);
}
}
}
/**
* La importacion se ejecuta al final asi se procesa despues de manipular el ML de Efs
*/
function post_eventos()
{
if ($this->disparar_importacion_efs) {
if (isset($this->s__importacion_efs['datos_tabla'])) {
$clave = array('proyecto' => toba_editor::get_proyecto_cargado(), 'componente' => $this->s__importacion_efs['datos_tabla']);
$dt = toba_constructor::get_info($clave, 'toba_datos_tabla');
$this->s__importacion_efs = $dt->exportar_datos_efs($this->s__importacion_efs['pk']);
foreach ($this->s__importacion_efs as $ef) {
try {
if (!$this->get_tabla()->existe_fila_condicion(array($this->campo_clave => $ef[$this->campo_clave]))) {
$this->get_tabla()->nueva_fila($ef);
}
} catch (toba_error $e) {
toba::notificacion()->agregar("Error agregando el EF '{$ef[$this->campo_clave]}'. " . $e->getMessage());
}
}
}
$this->disparar_importacion_efs = false;
}
}
function procesar()
{
toba::logger_ws()->debug('Servicio Llamado: ' . $this->info['basica']['item']);
toba::logger_ws()->set_checkpoint();
set_error_handler('toba_logger_ws::manejador_errores_recuperables', E_ALL);
$this->validar_componente();
//-- Pide los datos para construir el componente, WSF no soporta entregar objetos creados
$clave = array();
$clave['proyecto'] = $this->info['objetos'][0]['objeto_proyecto'];
$clave['componente'] = $this->info['objetos'][0]['objeto'];
list($tipo, $clase, $datos) = toba_constructor::get_runtime_clase_y_datos($clave, $this->info['objetos'][0]['clase'], false);
agregar_dir_include_path(toba_dir() . '/php/3ros/wsf');
$opciones_extension = toba_servicio_web::_get_opciones($this->info['basica']['item'], $clase);
$wsdl = strpos($_SERVER['REQUEST_URI'], "?wsdl") !== false;
$sufijo = 'op__';
$metodos = array();
$reflexion = new ReflectionClass($clase);
foreach ($reflexion->getMethods() as $metodo) {
if (strpos($metodo->name, $sufijo) === 0) {
$servicio = substr($metodo->name, strlen($sufijo));
$prefijo = $wsdl ? '' : '_';
$metodos[$servicio] = $prefijo . $metodo->name;
}
}
$opciones = array();
$opciones['serviceName'] = $this->info['basica']['item'];
$opciones['classes'][$clase]['operations'] = $metodos;
$opciones = array_merge($opciones, $opciones_extension);
$this->log->debug("Opciones del servidor: " . var_export($opciones, true), 'toba');
$opciones['classes'][$clase]['args'] = array($datos);
toba::logger_ws()->set_checkpoint();
$service = new WSService($opciones);
$service->reply();
$this->log->debug("Fin de servicio web", 'toba');
}
