Context Navigation

← Previous Changeset
Next Changeset →

Changeset 337

Timestamp:

06/29/08 01:56:47 (4 years ago)

Author:

deivinsontejeda

Message:

Estandarizacion a nivel de codigo utilizando php_beautifier y phpcs extensiones de PEAR para tal fin...

Files:

: 1 modified

0.5/library/kumbia/db/active_record_base/active_record_base.php (modified) (3 diffs)

Legend:

: Unmodified
: Added
: Removed

0.5/library/kumbia/db/active_record_base/active_record_base.php

r336	r337
1	1	<?php
2
3	2	/**
4	3	* Kumbia PHP Framework
…	…
15	14	*
16	15	* @category Kumbia
17		* @package Db
	16	* @package Db
18	17	* @subpackage ActiveRecord
19		* @copyright Copyright (c) 2005-2007 Andres Felipe Gutierrez (andresfelipe at vagoogle.net)
20		* @copyright Copyright (C) 2007-2007 Roger Jose Padilla Camacho (rogerjose81 at gmail.com)
21		* @copyright Copyright (C) 2007-2008 Emilio Rafael Silveira Tovar (emilio.rst at gmail.com)
	18	* @copyright Copyright (c) 2005-2007 Andres Felipe Gutierrez (andresfelipe at vagoogle.net)
	19	* @copyright Copyright (C) 2007-2007 Roger Jose Padilla Camacho (rogerjose81 at gmail.com)
	20	* @copyright Copyright (C) 2007-2008 Emilio Rafael Silveira Tovar (emilio.rst at gmail.com)
	21	* @copyright Copyright (C) 2007-2008 Deivinson Tejeda Brito (deivinsontejeda at gmail.com)
22	22	* @license http://www.kumbia.org/license.txt GNU/GPL
23	23	*/
24
25	24	/**
26	25	* ActiveRecordException
27	26	*/
28	27	require_once "library/kumbia/db/active_record_base/exception.php";
29
30	28	/**
31	29	* ActiveRecordBase Clase para el Mapeo Objeto Relacional
…	…
67	65	* mapearia los resultados de un select directamente a un Objeto (En Desarrollo)
68	66	*
69		* @category Kumbia
70		* @package Db
71		* @subpackage ActiveRecord
72		* @copyright Copyright (c) 2005-2007 Andres Felipe Gutierrez (andresfelipe at vagoogle.net)
73		* @copyright Copyright (C) 2007-2007 Roger Jose Padilla Camacho(rogerjose81 at gmail.com)
74		* @copyright Copyright (C) 2008-2008 Emilio Rafael Silveira Tovar(emilio.rst at gmail.com)
75		* @license http://www.kumbia.org/license.txt GNU/GPL
76		* @access public
77	67	*/
78	68	class ActiveRecordBase extends Object {
79
80		//Soportados
81		/**
82		* Resource de conexion a la base de datos
83		*
84		* @var DbBase
85		*/
86		public $db;
87
88		/**
89		* Modo a utilizar para que el modelo acceda a la bd, utiliza
90		* los modos que se encuentran en environment.ini, por defecto
91		* se considera el definido en config.ini para la aplicacion
92		*
93		* @var string
94		**/
95		protected $mode;
96
97		/**
98		* Schema donde esta la tabla
99		*
100		* @var string
101		*/
102		protected $schema;
103
104		/**
105		* Tabla utilizada para realizar el mapeo
106		*
107		* @var string
108		*/
109		protected $source;
110
111		/**
112		* Numero de resultados generados en la ultima consulta
113		*
114		* @var integer
115		*/
116		public $count;
117
118		/**
119		* Nombres de los atributos de la entidad
120		*
121		* @var array
122		*/
123		public $fields = array();
124
125		/**
126		* LLaves primarias de la entidad
127		*
128		* @var array
129		*/
130		public $primary_key = array();
131
132		/**
133		* Campos que no son llave primaria
134		*
135		* @var array
136		*/
137		public $non_primary = array();
138
139		/**
140		* Campos que no permiten nulos
141		*
142		* @var array
143		*/
144		public $not_null = array();
145
146		/**
147		* Campos que tienen valor por defecto
148		*
149		* @var array
150		*/
151		private $_with_default = array();
152
153		/**
154		* Nombres de atributos, es lo mismo que fields
155		*
156		* @var array
157		*/
158		public $attributes_names = array();
159
160		/**
161		* Indica si la clase corresponde a un mapeo de una vista
162		* en la base de datos
163		*
164		* @var boolean
165		*/
166		public $is_view = false;
167
168		/**
169		* Indica si el modelo esta en modo debug
170		*
171		* @var boolean
172		*/
173		public $debug = false;
174
175		/**
176		* Indica si se logearan los mensajes generados por la clase
177		*
178		* @var mixed
179		*/
180		public $logger = false;
181
182		/**
183		* Indica si los datos del modelo deben ser persistidos
184		*
185		* @var boolean
186		*/
187		public $persistent = false;
188
189		//:Privados
190		/**
191		* Campos que les ser� validado el tama�o
192		*
193		* @var array
194		*/
195		private $_validates_length = array();
196
197		/**
198		* Campos que ser�n validados si son numericos
199		*
200		* @var array
201		*/
202		private $_validates_numericality = array();
203
204		/**
205		* Campos que seran validados si son email
206		*
207		* @var array
208		*/
209		private $_validates_email = array();
210
211		/**
212		* Campos que ser�n validados si son Fecha
213		*
214		* @var array
215		*/
216		private $_validates_date = array();
217
218		/**
219		* Campos que seran validados si son unicos
220		*
221		* @var array
222		*/
223		private $_validates_uniqueness = array();
224
225		/**
226		* Campos que deberan tener valores dentro de una lista
227		* establecida
228		*
229		* @var array
230		*/
231		private $_validates_inclusion = array();
232
233		/**
234		* Campos que deberan tener valores por fuera de una lista
235		* establecida
236		*
237		* @var array
238		*/
239		private $_validates_exclusion = array();
240
241		/**
242		* Campos que seran validados contra un formato establecido
243		*
244		* @var array
245		*/
246		private $_validates_format = array();
247
248		/**
249		* Campos que son obligatorios, no pueden ser nulos
250		*
251		* @var array
252		*/
253		private $_validates_presence = array();
254
255		/**
256		* Campos que terminan en _in
257		*
258		* @var array
259		*/
260		private $_in = array();
261
262		/**
263		* Campos que terminan en _at
264		*
265		* @var array
266		*/
267		private $_at = array();
268
269		/**
270		* Variable para crear una condicion basada en los
271		* valores del where
272		*
273		* @var string
274		*/
275		private $_where_pk;
276
277		/**
278		* Indica si ya se han obtenido los metadatos del Modelo
279		*
280		* @var boolean
281		*/
282		private $_dumped = false;
283
284		/**
285		* Indica si hay bloqueo sobre los warnings cuando una propiedad
286		* del modelo no esta definida-
287		*
288		* @var boolean
289		*/
290		private $_dump_lock = false;
291
292		/**
293		* Tipos de datos de los campos del modelo
294		*
295		* @var array
296		*/
297		private $_data_type = array();
298
299		/**
300		* Relaciones a las cuales tiene una cardinalidad 1-1
301		*
302		* @var array
303		*/
304		private $_has_one = array();
305
306		/**
307		* Relaciones a las cuales tiene una cardinalidad 1-n
308		*
309		* @var array
310		*/
311		private $_has_many = array();
312
313		/**
314		* Relaciones a las cuales tiene una cardinalidad 1-1
315		*
316		* @var array
317		*/
318		private $_belongs_to = array();
319
320		/**
321		* Relaciones a las cuales tiene una cardinalidad n-n (muchos a muchos) o 1-n inversa
322		*
323		* @var array
324		*/
325		private $_has_and_belongs_to_many = array();
326
327		/**
328		* Clases de las cuales es padre la clase actual
329		*
330		* @var array
331		*/
332		public $parent_of = array();
333
334		/**
335		* Persistance Models Meta-data
336		*/
337		static public $models;
338
339
340		/**
341		* Constructor del Modelo
342		*/
343		function __construct(){
344		if(!$this->source){
345		$this->_model_name();
346		}
347
348		/**
349		* Inicializa el modelo en caso de que exista initialize
350		*/
351		if(method_exists($this, "initialize")){
352		$this->initialize();
353		}
354
355		if(func_num_args()){
356		$params = func_get_args();
357		if(is_array($params[0])) {
358		$params = $params[0];
359		} else {
360		$params = get_params($params);
361		}
362		$this->dump_result_self($params);
363		}
364		}
365
366		/**
367		* Obtiene el nombre de la relacion en el RDBM a partir del nombre de la clase
368		*
369		*/
370		private function _model_name(){
371		if(!$this->source){
372		$this->source = uncamelize(lcfirst(get_class($this)));
373		}
374		}
375
376		/**
377		* Establece publicamente el $source de la tabla
378		*
379		* @param string $source
380		*/
381		public function set_source($source){
382		$this->source = $source;
383		}
384
385		/**
386		* Devuelve el source actual
387		*
388		* @return string
389		*/
390		public function get_source(){
391		return $this->source;
392		}
393
394		/**
395		* Establece publicamente el $mode del modelo
396		*
397		* @param string $mode
398		*/
399		public function set_mode($mode){
400		$this->mode = $mode;
401		}
402
403		/**
404		* Devuelve el mode actual
405		*
406		* @return string
407		*/
408		public function get_mode(){
409		if($this->mode) {
410		return $this->mode;
411		} else {
412		return Kumbia::get_active_app_mode();
413		}
414		}
415
416		/**
417		* Pregunta si el ActiveRecord ya ha consultado la informacion de metadatos
418		* de la base de datos o del registro persistente
419		*
420		* @return boolean
421		*/
422		public function is_dumped(){
423		return $this->_dumped;
424		}
425
426		/**
427		* Valida que los valores que sean leidos del objeto ActiveRecord esten definidos
428		* previamente o sean atributos de la entidad
429		*
430		* @param string $property
431		*/
432		function __get($property){
433		$this->_connect();
434		if(!$this->_dump_lock){
435		if(!isset($this->$property)){
436		if(array_key_exists($property, $this->_belongs_to)){
437		$relation = $this->_belongs_to[$property];
438		if(isset(kumbia::$models[$relation->model])) {
439		$assoc_obj = kumbia::$models[$relation->model]->find_first($this->{$relation->fk});
440		return $assoc_obj;
441		} else {
442		ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
443		return null;
444		}
445		} elseif(array_key_exists($property, $this->_has_one)) {
446		$relation = $this->_has_one[$property];
447		if(isset(kumbia::$models[$relation->model])) {
448		if($this->{$this->primary_key[0]}) {
449		$assoc_obj = kumbia::$models[$relation->model]->find_first("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]})}");
450		return $assoc_obj;
451		} else {
452		return null;
453		}
454		} else {
455		ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
456		return null;
457		}
458		} elseif(array_key_exists($property, $this->_has_many)) {
459		$relation = $this->_has_many[$property];
460		if(isset(kumbia::$models[$relation->model])) {
461		if($this->{$this->primary_key[0]}) {
462		$assoc_objs = kumbia::$models[$relation->model]->find("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]})}");
463		return $assoc_objs;
464		} else {
465		return array();
466		}
467		} else {
468		ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
469		return null;
470		}
471		} elseif(array_key_exists($property, $this->_has_and_belongs_to_many)){
472		$relation = $this->_has_and_belongs_to_many[$property];
473		if(isset(kumbia::$models[$relation->model])) {
474		$relation_model = kumbia::$models[$relation->model];
475		$relation_model->connect();
476		$source = $this->source;
477		$relation_source = $relation_model->source;
478
479		/**
480		* Cargo atraves de que tabla se efectuara la relacion
481		**/
482		if(!isset($relation->through)) {
483		if($source > $relation_source) {
484		$relation->through = "{$this->source}_{$relation_source}";
485		} else {
486		$relation->through = "{$relation_source}_{$this->source}";
487		}
488		}
489
490		if($this->{$this->primary_key[0]}) {
491		$assoc_objs = kumbia::$models[$relation->model]->find_all_by_sql("SELECT $relation_source.* FROM $relation_source, {$relation->through}, $source
492		WHERE {$relation->through}.{$relation->key} = {$this->db->add_quotes($this->{$this->primary_key[0]})}
	69	//Soportados
	70
	71	/**
	72	* Resource de conexion a la base de datos
	73	*
	74	* @var DbBase
	75	*/
	76	public $db;
	77	/**
	78	* Modo a utilizar para que el modelo acceda a la bd, utiliza
	79	* los modos que se encuentran en environment.ini, por defecto
	80	* se considera el definido en config.ini para la aplicacion
	81	*
	82	* @var string
	83	*
	84	*/
	85	protected $mode;
	86	/**
	87	* Schema donde esta la tabla
	88	*
	89	* @var string
	90	*/
	91	protected $schema;
	92	/**
	93	* Tabla utilizada para realizar el mapeo
	94	*
	95	* @var string
	96	*/
	97	protected $source;
	98	/**
	99	* Numero de resultados generados en la ultima consulta
	100	*
	101	* @var integer
	102	*/
	103	public $count;
	104	/**
	105	* Nombres de los atributos de la entidad
	106	*
	107	* @var array
	108	*/
	109	public $fields = array();
	110	/**
	111	* LLaves primarias de la entidad
	112	*
	113	* @var array
	114	*/
	115	public $primary_key = array();
	116	/**
	117	* Campos que no son llave primaria
	118	*
	119	* @var array
	120	*/
	121	public $non_primary = array();
	122	/**
	123	* Campos que no permiten nulos
	124	*
	125	* @var array
	126	*/
	127	public $not_null = array();
	128	/**
	129	* Campos que tienen valor por defecto
	130	*
	131	* @var array
	132	*/
	133	private $_with_default = array();
	134	/**
	135	* Nombres de atributos, es lo mismo que fields
	136	*
	137	* @var array
	138	*/
	139	public $attributes_names = array();
	140	/**
	141	* Indica si la clase corresponde a un mapeo de una vista
	142	* en la base de datos
	143	*
	144	* @var boolean
	145	*/
	146	public $is_view = false;
	147	/**
	148	* Indica si el modelo esta en modo debug
	149	*
	150	* @var boolean
	151	*/
	152	public $debug = false;
	153	/**
	154	* Indica si se logearan los mensajes generados por la clase
	155	*
	156	* @var mixed
	157	*/
	158	public $logger = false;
	159	/**
	160	* Indica si los datos del modelo deben ser persistidos
	161	*
	162	* @var boolean
	163	*/
	164	public $persistent = false;
	165	//:Privados
	166
	167	/**
	168	* Campos que les ser� validado el tama�o
	169	*
	170	* @var array
	171	*/
	172	private $_validates_length = array();
	173	/**
	174	* Campos que ser�n validados si son numericos
	175	*
	176	* @var array
	177	*/
	178	private $_validates_numericality = array();
	179	/**
	180	* Campos que seran validados si son email
	181	*
	182	* @var array
	183	*/
	184	private $_validates_email = array();
	185	/**
	186	* Campos que ser�n validados si son Fecha
	187	*
	188	* @var array
	189	*/
	190	private $_validates_date = array();
	191	/**
	192	* Campos que seran validados si son unicos
	193	*
	194	* @var array
	195	*/
	196	private $_validates_uniqueness = array();
	197	/**
	198	* Campos que deberan tener valores dentro de una lista
	199	* establecida
	200	*
	201	* @var array
	202	*/
	203	private $_validates_inclusion = array();
	204	/**
	205	* Campos que deberan tener valores por fuera de una lista
	206	* establecida
	207	*
	208	* @var array
	209	*/
	210	private $_validates_exclusion = array();
	211	/**
	212	* Campos que seran validados contra un formato establecido
	213	*
	214	* @var array
	215	*/
	216	private $_validates_format = array();
	217	/**
	218	* Campos que son obligatorios, no pueden ser nulos
	219	*
	220	* @var array
	221	*/
	222	private $_validates_presence = array();
	223	/**
	224	* Campos que terminan en _in
	225	*
	226	* @var array
	227	*/
	228	private $_in = array();
	229	/**
	230	* Campos que terminan en _at
	231	*
	232	* @var array
	233	*/
	234	private $_at = array();
	235	/**
	236	* Variable para crear una condicion basada en los
	237	* valores del where
	238	*
	239	* @var string
	240	*/
	241	private $_where_pk;
	242	/**
	243	* Indica si ya se han obtenido los metadatos del Modelo
	244	*
	245	* @var boolean
	246	*/
	247	private $_dumped = false;
	248	/**
	249	* Indica si hay bloqueo sobre los warnings cuando una propiedad
	250	* del modelo no esta definida-
	251	*
	252	* @var boolean
	253	*/
	254	private $_dump_lock = false;
	255	/**
	256	* Tipos de datos de los campos del modelo
	257	*
	258	* @var array
	259	*/
	260	private $_data_type = array();
	261	/**
	262	* Relaciones a las cuales tiene una cardinalidad 1-1
	263	*
	264	* @var array
	265	*/
	266	private $_has_one = array();
	267	/**
	268	* Relaciones a las cuales tiene una cardinalidad 1-n
	269	*
	270	* @var array
	271	*/
	272	private $_has_many = array();
	273	/**
	274	* Relaciones a las cuales tiene una cardinalidad 1-1
	275	*
	276	* @var array
	277	*/
	278	private $_belongs_to = array();
	279	/**
	280	* Relaciones a las cuales tiene una cardinalidad n-n (muchos a muchos) o 1-n inversa
	281	*
	282	* @var array
	283	*/
	284	private $_has_and_belongs_to_many = array();
	285	/**
	286	* Clases de las cuales es padre la clase actual
	287	*
	288	* @var array
	289	*/
	290	public $parent_of = array();
	291	/**
	292	* Persistance Models Meta-data
	293	*/
	294	static public $models;
	295	/**
	296	* Constructor del Modelo
	297	*/
	298	function __construct() {
	299	if (!$this->source) {
	300	$this->_model_name();
	301	}
	302	/**
	303	* Inicializa el modelo en caso de que exista initialize
	304	*/
	305	if (method_exists($this, "initialize")) {
	306	$this->initialize();
	307	}
	308	if (func_num_args()) {
	309	$params = func_get_args();
	310	if (is_array($params[0])) {
	311	$params = $params[0];
	312	} else {
	313	$params = get_params($params);
	314	}
	315	$this->dump_result_self($params);
	316	}
	317	}
	318	/**
	319	* Obtiene el nombre de la relacion en el RDBM a partir del nombre de la clase
	320	*
	321	*/
	322	private function _model_name() {
	323	if (!$this->source) {
	324	$this->source = uncamelize(lcfirst(get_class($this)));
	325	}
	326	}
	327	/**
	328	* Establece publicamente el $source de la tabla
	329	*
	330	* @param string $source
	331	*/
	332	public function set_source($source) {
	333	$this->source = $source;
	334	}
	335	/**
	336	* Devuelve el source actual
	337	*
	338	* @return string
	339	*/
	340	public function get_source() {
	341	return $this->source;
	342	}
	343	/**
	344	* Establece publicamente el $mode del modelo
	345	*
	346	* @param string $mode
	347	*/
	348	public function set_mode($mode) {
	349	$this->mode = $mode;
	350	}
	351	/**
	352	* Devuelve el mode actual
	353	*
	354	* @return string
	355	*/
	356	public function get_mode() {
	357	if ($this->mode) {
	358	return $this->mode;
	359	} else {
	360	return Kumbia::get_active_app_mode();
	361	}
	362	}
	363	/**
	364	* Pregunta si el ActiveRecord ya ha consultado la informacion de metadatos
	365	* de la base de datos o del registro persistente
	366	*
	367	* @return boolean
	368	*/
	369	public function is_dumped() {
	370	return $this->_dumped;
	371	}
	372	/**
	373	* Valida que los valores que sean leidos del objeto ActiveRecord esten definidos
	374	* previamente o sean atributos de la entidad
	375	*
	376	* @param string $property
	377	*/
	378	function __get($property) {
	379	$this->_connect();
	380	if (!$this->_dump_lock) {
	381	if (!isset($this->$property)) {
	382	if (array_key_exists($property, $this->_belongs_to)) {
	383	$relation = $this->_belongs_to[$property];
	384	if (isset(kumbia::$models[$relation->model])) {
	385	$assoc_obj = kumbia::$models[$relation->model]->find_first($this->{$relation->fk});
	386	return $assoc_obj;
	387	} else {
	388	ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
	389	return null;
	390	}
	391	} elseif (array_key_exists($property, $this->_has_one)) {
	392	$relation = $this->_has_one[$property];
	393	if (isset(kumbia::$models[$relation->model])) {
	394	if ($this->{$this->primary_key[0]}) {
	395	$assoc_obj = kumbia::$models[$relation->model]->find_first("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]}) }");
	396	return $assoc_obj;
	397	} else {
	398	return null;
	399	}
	400	} else {
	401	ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
	402	return null;
	403	}
	404	} elseif (array_key_exists($property, $this->_has_many)) {
	405	$relation = $this->_has_many[$property];
	406	if (isset(kumbia::$models[$relation->model])) {
	407	if ($this->{$this->primary_key[0]}) {
	408	$assoc_objs = kumbia::$models[$relation->model]->find("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]}) }");
	409	return $assoc_objs;
	410	} else {
	411	return array();
	412	}
	413	} else {
	414	ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
	415	return null;
	416	}
	417	} elseif (array_key_exists($property, $this->_has_and_belongs_to_many)) {
	418	$relation = $this->_has_and_belongs_to_many[$property];
	419	if (isset(kumbia::$models[$relation->model])) {
	420	$relation_model = kumbia::$models[$relation->model];
	421	$relation_model->connect();
	422	$source = $this->source;
	423	$relation_source = $relation_model->source;
	424	/**
	425	* Cargo atraves de que tabla se efectuara la relacion
	426	*
	427	*/
	428	if (!isset($relation->through)) {
	429	if ($source > $relation_source) {
	430	$relation->through = "{$this->source}_{$relation_source}";
	431	} else {
	432	$relation->through = "{$relation_source}_{$this->source}";
	433	}
	434	}
	435	if ($this->{$this->primary_key[0]}) {
	436	$assoc_objs = kumbia::$models[$relation->model]->find_all_by_sql("SELECT $relation_source.* FROM $relation_source, {$relation->through}, $source
	437	WHERE {$relation->through}.{$relation->key} = {$this->db->add_quotes($this->{$this->primary_key[0]}) }
493	438	AND {$relation->through}.{$relation->fk} = $relation_source.{$relation_model->primary_key[0]}
494	439	AND {$relation->through}.{$relation->key} = $source.{$this->primary_key[0]}
495	440	ORDER BY $relation_source.{$relation_model->primary_key[0]}");
496		return $assoc_objs;
497		} else {
498		return array();
499		}
500		} else {
501		ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
502		return null;
503		}
504		} else {
505		return null;
506		}
507		}
508		}
509		return $this->$property;
510		}
511
512		/**
513		* Valida que los valores que sean asignados al objeto ActiveRecord esten definidos
514		* o sean atributos de la entidad
515		*
516		* @param string $property
517		* @param mixed $value
518		*/
519		function __set($property, $value){
520		$this->_connect();
521		if(!$this->_dump_lock){
522		if(!isset($this->$property)){
523		if(array_key_exists($property, $this->_belongs_to)) {
524		$relation = $this->_belongs_to[$property];
525		$value->connect();
526		$this->{$relation->fk} = $value->{$value->primary_key[0]};
527		} elseif(array_key_exists($property, $this->_has_one)) {
528		$relation = $this->_has_one[$property];
529		$value->{$relation->fk} = $this->{$this->primary_key[0]};
530		}
531		} elseif($property=="source") {
532		$value = ActiveRecord::sql_item_sanizite($value);
533		}
534		}
535		$this->$property = $value;
536		}
537
538		/**
539		* Devuelve un valor o un listado dependiendo del tipo de Relación
540		*
541		*/
542		public function __call($method, $args=array()){
543		$this->_connect();
544
545		$has_relation = false;
546
547		if(substr($method, 0, 8)=="find_by_"){
548		$field = substr($method, 8);
549		ActiveRecord::sql_item_sanizite($field);
550		if(isset($args[0])){
551		$arg = array("conditions: $field = {$this->db->add_quotes($args[0])}");
552		unset($args[0]);
553		} else {
554		$arg = array();
555		}
556		return call_user_func_array(array($this, "find_first"), array_merge($arg, $args));
557		}
558
559		if(substr($method, 0, 9)=="count_by_"){
560		$field = substr($method, 9);
561		ActiveRecord::sql_item_sanizite($field);
562		if(isset($args[0])){
563		$arg = array("conditions: $field = {$this->db->add_quotes($args[0])}");
564		unset($args[0]);
565		} else {
566		$arg = array();
567		}
568		return call_user_func_array(array($this, "count"), array_merge($arg, $args));
569		}
570
571		if(substr($method, 0, 12)=="find_all_by_"){
572		$field = substr($method, 12);
573		ActiveRecord::sql_item_sanizite($field);
574		if(isset($args[0])){
575		$arg = array("conditions: $field = {$this->db->add_quotes($args[0])}");
576		unset($args[0]);
577		} else {
578		$arg = array();
579		}
580		return call_user_func_array(array($this, "find"), array_merge($arg, $args));
581		}
582
583		$model = ereg_replace("^get", "", $method);
584		$mmodel = uncamelize(lcfirst($model));
585
586		if(array_key_exists($mmodel, $this->_belongs_to)){
587		$has_relation = true;
588		$relation = $this->_belongs_to[$mmodel];
589		if(kumbia::$models[$relation->model]){
590		return kumbia::$models[$relation->model]->find_first($this->{$relation->fk});
591		}
592		}
593		if(array_key_exists($mmodel, $this->_has_many)){
594		$this->_connect();
595		$has_relation = true;
596		$relation = $this->_has_many[$mmodel];
597		if(kumbia::$models[$relation->model]){
598		if($this->{$this->primary_key[0]}){
599		return kumbia::$models[$relation->model]->find("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]})}");
600		} else {
601		return array();
602		}
603		}
604		}
605		if(array_key_exists($mmodel, $this->_has_one)){
606		$this->_connect();
607		$has_relation = true;
608		$relation = $this->_has_one[$mmodel];
609		if(kumbia::$models[$relation->model]){
610		if($this->{$this->primary_key[0]}){
611		return kumbia::$models[$relation->model]->find_first("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]})}");
612		} else {
613		return null;
614		}
615		}
616		}
617
618		if(array_key_exists($mmodel, $this->_has_and_belongs_to_many)){
619		$has_relation = true;
620		$relation = $this->_has_and_belongs_to_many[$mmodel];
621		if(kumbia::$models[$relation->model]){
622		if($this->{$this->primary_key[0]}){
623		$source = $this->source;
624		$relation_model = kumbia::$models[$relation->model];
625		$relation_model->connect();
626		$relation_source = $relation_model->source;
627
628		/**
629		* Cargo atraves de que tabla se efectuara la relacion
630		**/
631		if(!isset($relation->through)) {
632		if($source > $relation_source) {
633		$relation->through = "{$this->source}_{$relation_source}";
634		} else {
635		$relation->through = "{$relation_source}_{$this->source}";
636		}
637		}
638
639		return kumbia::$models[$relation->model]->find_all_by_sql("SELECT $relation_source.* FROM $relation_source, {$relation->through}, $source
640		WHERE {$relation->through}.{$relation->key} = {$this->db->add_quotes($this->{$this->primary_key[0]})}
	441	return $assoc_objs;
	442	} else {
	443	return array();
	444	}
	445	} else {
	446	ActiveRecordException::display_warning("Propiedad no definida", "Propiedad indefinida '$property' leida de el modelo '$this->source'", $this->source);
	447	return null;
	448	}
	449	} else {
	450	return null;
	451	}
	452	}
	453	}
	454	return $this->$property;
	455	}
	456	/**
	457	* Valida que los valores que sean asignados al objeto ActiveRecord esten definidos
	458	* o sean atributos de la entidad
	459	*
	460	* @param string $property
	461	* @param mixed $value
	462	*/
	463	function __set($property, $value) {
	464	$this->_connect();
	465	if (!$this->_dump_lock) {
	466	if (!isset($this->$property)) {
	467	if (array_key_exists($property, $this->_belongs_to)) {
	468	$relation = $this->_belongs_to[$property];
	469	$value->connect();
	470	$this->{$relation->fk} = $value->{$value->primary_key[0]};
	471	} elseif (array_key_exists($property, $this->_has_one)) {
	472	$relation = $this->_has_one[$property];
	473	$value->{$relation->fk} = $this->{$this->primary_key[0]};
	474	}
	475	} elseif ($property == "source") {
	476	$value = ActiveRecord::sql_item_sanizite($value);
	477	}
	478	}
	479	$this->$property = $value;
	480	}
	481	/**
	482	* Devuelve un valor o un listado dependiendo del tipo de Relación
	483	*
	484	*/
	485	public function __call($method, $args = array()) {
	486	$this->_connect();
	487	$has_relation = false;
	488	if (substr($method, 0, 8) == "find_by_") {
	489	$field = substr($method, 8);
	490	ActiveRecord::sql_item_sanizite($field);
	491	if (isset($args[0])) {
	492	$arg = array("conditions: $field = {$this->db->add_quotes($args[0]) }");
	493	unset($args[0]);
	494	} else {
	495	$arg = array();
	496	}
	497	return call_user_func_array(array($this, "find_first"), array_merge($arg, $args));
	498	}
	499	if (substr($method, 0, 9) == "count_by_") {
	500	$field = substr($method, 9);
	501	ActiveRecord::sql_item_sanizite($field);
	502	if (isset($args[0])) {
	503	$arg = array("conditions: $field = {$this->db->add_quotes($args[0]) }");
	504	unset($args[0]);
	505	} else {
	506	$arg = array();
	507	}
	508	return call_user_func_array(array($this, "count"), array_merge($arg, $args));
	509	}
	510	if (substr($method, 0, 12) == "find_all_by_") {
	511	$field = substr($method, 12);
	512	ActiveRecord::sql_item_sanizite($field);
	513	if (isset($args[0])) {
	514	$arg = array("conditions: $field = {$this->db->add_quotes($args[0]) }");
	515	unset($args[0]);
	516	} else {
	517	$arg = array();
	518	}
	519	return call_user_func_array(array($this, "find"), array_merge($arg, $args));
	520	}
	521	$model = ereg_replace("^get", "", $method);
	522	$mmodel = uncamelize(lcfirst($model));
	523	if (array_key_exists($mmodel, $this->_belongs_to)) {
	524	$has_relation = true;
	525	$relation = $this->_belongs_to[$mmodel];
	526	if (kumbia::$models[$relation->model]) {
	527	return kumbia::$models[$relation->model]->find_first($this->{$relation->fk});
	528	}
	529	}
	530	if (array_key_exists($mmodel, $this->_has_many)) {
	531	$this->_connect();
	532	$has_relation = true;
	533	$relation = $this->_has_many[$mmodel];
	534	if (kumbia::$models[$relation->model]) {
	535	if ($this->{$this->primary_key[0]}) {
	536	return kumbia::$models[$relation->model]->find("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]}) }");
	537	} else {
	538	return array();
	539	}
	540	}
	541	}
	542	if (array_key_exists($mmodel, $this->_has_one)) {
	543	$this->_connect();
	544	$has_relation = true;
	545	$relation = $this->_has_one[$mmodel];
	546	if (kumbia::$models[$relation->model]) {
	547	if ($this->{$this->primary_key[0]}) {
	548	return kumbia::$models[$relation->model]->find_first("{$relation->fk}={$this->db->add_quotes($this->{$this->primary_key[0]}) }");
	549	} else {
	550	return null;
	551	}
	552	}
	553	}
	554	if (array_key_exists($mmodel, $this->_has_and_belongs_to_many)) {
	555	$has_relation = true;
	556	$relation = $this->_has_and_belongs_to_many[$mmodel];
	557	if (kumbia::$models[$relation->model]) {
	558	if ($this->{$this->primary_key[0]}) {
	559	$source = $this->source;
	560	$relation_model = kumbia::$models[$relation->model];
	561	$relation_model->connect();
	562	$relation_source = $relation_model->source;
	563	/**
	564	* Cargo atraves de que tabla se efectuara la relacion
	565	*
	566	*/
	567	if (!isset($relation->through)) {
	568	if ($source > $relation_source) {
	569	$relation->through = "{$this->source}_{$relation_source}";
	570	} else {
	571	$relation->through = "{$relation_source}_{$this->source}";
	572	}
	573	}
	574	return kumbia::$models[$relation->model]->find_all_by_sql("SELECT $relation_source.* FROM $relation_source, {$relation->through}, $source
	575	WHERE {$relation->through}.{$relation->key} = {$this->db->add_quotes($this->{$this->primary_key[0]}) }
641	576	AND {$relation->through}.{$relation->fk} = $relation_source.{$relation_model->primary_key[0]}
642	577	AND {$relation->through}.{$relation->key} = $source.{$this->primary_key[0]}
643	578	ORDER BY $relation_source.{$relation_model->primary_key[0]}");
644		} else {
645		return array();
646		}
647		}
648		}
649
650		try {
651		if(method_exists($this, $method)){
652		call_user_func_array(array($this, $method), $args);
653		} else {
654		if($has_relation){
655		throw new ActiveRecordException("No existe el modelo '$model' para relacionar con ActiveRecord::{$this->source}");
656		} else {
657		throw new ActiveRecordException("No existe el método '$method' en ActiveRecord::".get_class($this));
658		}
659		}
660		}
661		catch(Exception $e){
662		$this->exceptions($e);
663		}
664		return $this->$method($args);
665
666		}
667
668		/**
669		* Se conecta a la base de datos y descarga los meta-datos si es necesario
670		*
671		* @param boolean $new_connection
672		*/
673		private function _connect($new_connection=false){
674		if(!is_object($this->db)\|\|$new_connection){
675		if($this->mode) {
676		$this->db = DbBase::raw_connect($new_connection, "mode: {$this->mode}");
677		} else {
678		$this->db = DbBase::raw_connect($new_connection);
679		}
680		}
681		$this->db->debug = $this->debug;
682		$this->db->logger = $this->logger;
683		$this->dump();
684		}
685
686		/**
687		* Cargar los metadatos de la tabla
688		*
689		*/
690		public function dump_model(){
691		$this->_connect();
692		}
693
694		/**
695		* Verifica si la tabla definida en $this->source existe
696		* en la base de datos y la vuelca en dump_info
697		*
698		* @return boolean
699		*/
700		protected function dump(){
701		if($this->_dumped){
702		return false;
703		}
704		if($this->source) {
705		$this->source = str_replace(";", "", strtolower($this->source));
706		} else {
707		$this->_model_name();
708		if(!$this->source){
709		return false;
710		}
711		}
712		$table = $this->source;
713		$schema = $this->schema;
714		if(!count(ActiveRecord::get_meta_data($this->source))){
715		$this->_dumped = true;
716		if($this->db->table_exists($table, $schema)){
717		$this->_dump_info($table, $schema);
718		} else {
719		throw new ActiveRecordException("No existe la tabla '$table' en la base de datos");
720		return false;
721		}
722		if(!count($this->primary_key)){
723		if(!$this->is_view){
724		throw new ActiveRecordException("No se ha definido una llave primaria para la tabla '$table' esto imposibilita crear el ActiveRecord para esta entidad");
725		return false;
726		}
727		}
728		} else {
729		if(!$this->is_dumped()){
730		$this->_dumped = true;
731		$this->_dump_info($table, $schema);
732		}
733		}
734		return true;
735		}
736
737		/**
738		* Vuelca la información de la tabla $table en la base de datos
739		* para armar los atributos y meta-data del ActiveRecord
740		*
741		* @param string $table
742		* @return boolean
743		*/
744		private function _dump_info($table, $schema=''){
745		$this->_dump_lock = true;
746		if(!count(ActiveRecord::get_meta_data($table))){
747		$meta_data = $this->db->describe_table($table, $schema);
748		if($meta_data){
749		ActiveRecord::set_meta_data($table, $meta_data);
750		}
751		}
752		foreach(ActiveRecord::get_meta_data($table) as $field){
753		$this->fields[] = $field['Field'];
754		if($field['Key']=='PRI'){
755		$this->primary_key[] = $field['Field'];
756		} else $this->non_primary[] = $field['Field'];
757		/**
758		* Si se indica que no puede ser nulo, pero se indica un
759		* valor por defecto, entonces no se incluye en la lista, ya que
760		* al colocar un valor por defecto, el campo nunca sera nulo
761		**/
762		if($field['Null']=='NO' && !(isset($field['Default']) && $field['Default'])){
763		$this->not_null[] = $field['Field'];
764		}
765		if(isset($field['Default']) && $field['Default']) {
766		$this->_with_default[] = $field['Field'];
767		}
768		if($field['Type']){
769		$this->_data_type[$field['Field']] = strtolower($field['Type']);
770		}
771		if(substr($field['Field'], strlen($field['Field'])-3, 3)=='_at'){
772		$this->_at[] = $field['Field'];
773		}
774		if(substr($field['Field'], strlen($field['Field'])-3, 3)=='_in'){
775		$this->_in[] = $field['Field'];
776		}
777		}
778		$this->attributes_names = $this->fields;
779		$this->_dump_lock = false;
780		return true;
781		}
782
783		/**
784		* Commit a Transaction
785		*
786		* @return success
787		*/
788		public function commit(){
789		$this->_connect();
790		return $this->db->commit();
791		}
792
793		/**
794		* Rollback a Transaction
795		*
796		* @return success
797		*/
798		public function rollback(){
799		$this->_connect();
800		return $this->db->rollback();
801		}
802
803		/**
804		* Start a transaction in RDBM
805		*
806		* @return success
807		*/
808		public function begin(){
809		$this->_connect(true);
810		return $this->db->begin();
811		}
812
813		/**
814		* Find all records in this table using a SQL Statement
815		*
816		* @param string $sqlQuery
817		* @return ActiveRecord Cursor
818		*/
819		public function find_all_by_sql($sqlQuery){
820		$this->_connect();
821		$results = array();
822		foreach($this->db->fetch_all($sqlQuery) as $result){
823		$results[] = $this->dump_result($result);
824		}
825		return $results;
826		}
827		/**
828		* Find a record in this table using a SQL Statement
829		*
830		* @param string $sqlQuery
831		* @return ActiveRecord Cursor
832		*/
833		public function find_by_sql($sqlQuery){
834		$this->_connect();
835		$row = $this->db->fetch_one($sqlQuery);
836		if($row!==false){
837		$this->dump_result_self($row);
838		return $this->dump_result($row);
839		} else {
840		return false;
841		}
842		}
843
844		/**
845		* Execute a SQL Statement directly
846		*
847		* @param string $sqlQuery
848		* @return int affected
849		*/
850		public function sql($sqlQuery){
851		$this->_connect();
852		return $this->db->query($sqlQuery);
853		}
854
855		/**
856		* Return Fist Record
857		*
858		* @param mixed $what
859		* @param boolean $debug
860		*
861		* Recibe los mismos parametros que find
862		*
863		* @return ActiveRecord Cursor
864		*/
865		public function find_first($what=''){
866		$this->_connect();
867		$what = get_params(func_get_args());
868		$select = "SELECT ";
869		if(isset($what['columns'])){
870		$select.= ActiveRecord::sql_sanizite($what['columns']);
871		} elseif(isset($what['distinct'])) {
872		$select.='DISTINCT ';
873		$select.= $what['distinct'] ? ActiveRecord::sql_sanizite($what['distinct']) : join(",", $this->fields);
874		} else {
875		$select.= join(",", $this->fields);
876		}
877		if($this->schema){
878		$select.= " FROM {$this->schema}.{$this->source}";
879		} else {
880		$select.= " FROM {$this->source}";
881		}
882
883		$what['limit'] = 1;
884		$select.= $this->convert_params_to_sql($what);
885		$resp = false;
886		try {
887
888		$result = $this->db->fetch_one($select);
889		if($result){
890		$this->dump_result_self($result);
891		$resp = $this->dump_result($result);
892		}
893		}
894		catch(Exception $e){
895		$this->exceptions($e);
896		}
897		return $resp;
898		}
899
900		/**
901		* Find data on Relational Map table
902		*
903		* @param string $what
904		* @return ActiveRecord Cursor
905		*
906		* columns: columnas a utilizar
907		* conditions : condiciones de busqueda en WHERE
908		* join: inclusion inner join o outer join
909		* group : campo para grupo en GROUP BY
910		* having : condicion para el grupo
911		* order : campo para criterio de ordenamiento ORDER BY
912		* distinct: campos para hacer select distinct
913		*/
914		public function find($what=''){
915		$this->_connect();
916		$what = get_params(func_get_args());
917		$select = "SELECT ";
918		if(isset($what['columns'])){
919		$select.= $what['columns'] ? ActiveRecord::sql_sanizite($what['columns']) : join(",", $this->fields);
920		} elseif(isset($what['distinct'])) {
921		$select.='DISTINCT ';
922		$select.= $what['distinct'] ? ActiveRecord::sql_sanizite($what['distinct']) : join(",", $this->fields);
923		} else {
924		$select.= join(",", $this->fields);
925		}
926		if($this->schema){
927		$select.= " FROM {$this->schema}.{$this->source}";
928		} else {
929		$select.= " FROM {$this->source}";
930		}
931		$select.= $this->convert_params_to_sql($what);
932
933		$results = array();
934		$all_results = $this->db->in_query($select);
935		foreach($all_results AS $result){
936		$results[] = $this->dump_result($result);
937		}
938		$this->count = count($results);
939
940		if(isset($what[0]) && is_numeric($what[0])){
941		if(!isset($results[0])){
942		$this->count = 0;
943		return false;
944		} else {
945		$this->dump_result_self($all_results[0]);
946		$this->count = 1;
947		return $results[0];
948		}
949		} else {
950		$this->count = count($results);
951		return $results;
952		}
953		}
954
955		/*
956		* Arma una consulta SQL con el parametro $what, as�:
957		* $what = get_params(func_get_args());
958		* $select = "SELECT * FROM Clientes";
959		* $select.= $this->convert_params_to_sql($what);
960		*
961		* @param string $what
962		* @return string
963		*/
964		public function convert_params_to_sql($what = ''){
965		$select = "";
966		if(is_array($what)){
967		if(!isset($what['conditions'])) {
968		if(!isset($this->primary_key[0]) && (isset($this->id) \|\| $this->is_view)){
969		$this->primary_key[0] = "id";
970		}
971		ActiveRecord::sql_item_sanizite($this->primary_key[0]);
972		if(isset($what[0])){
973		if(is_numeric($what[0])){
974		$what['conditions'] = "{$this->primary_key[0]} = {$this->db->add_quotes($what[0])}";
975		} else {
976		if($what[0]==''){
977		$what['conditions'] = "{$this->primary_key[0]} = ''";
978		} else {
979		$what['conditions'] = $what[0];
980		}
981		}
982		}
983		}
984
985		if(isset($what['join']) && $what['join']){
986		$select.=" {$what['join']}";
987		}
988		if(isset($what['conditions']) && $what['conditions']){
989		$select.=" WHERE {$what['conditions']}";
990		}
991		if(isset($what['group']) && $what['group']){
992		$select.=" GROUP BY {$what['group']}";
993		}
994		if(isset($what['having']) && $what['having']){
995		$select.=" HAVING {$what['having']}";
996		}
997		if(isset($what['order'])&&$what['order']) {
998		ActiveRecord::sql_sanizite($what['order']);
999		$select.=" ORDER BY {$what['order']}";
1000		}
1001
1002		$limit_args = array($select);
1003		if(isset($what['limit'])) {
1004		array_push($limit_args, "limit: $what[limit]");
1005		}
1006		if(isset($what['offset'])) {
1007		array_push($limit_args, "offset: $what[offset]");
1008		}
1009		if(count($limit_args)>1) {
1010		$select = call_user_func_array(array($this,'limit'), $limit_args);
1011		}
1012
1013		} else {
1014		if(strlen($what)){
1015		if(is_numeric($what)){
1016		$select.= "WHERE {$this->primary_key[0]} = '$what'";
1017		} else {
1018		$select.= "WHERE $what";
1019		}
1020		}
1021		}
1022		return $select;
1023		}
1024
1025		/*
1026		* Devuelve una clausula LIMIT adecuada al RDBMS empleado
1027		*
1028		* limit: maxima cantidad de elementos a mostrar
1029		* offset: desde que elemento se comienza a mostrar
1030		*
1031		* @param string $sql consulta select
1032		* @return String clausula LIMIT adecuada al RDBMS empleado
1033		*/
1034		public function limit($sql){
1035		$args = func_get_args();
1036		return call_user_func_array(array($this->db, 'limit'), $args);
1037		}
1038
1039		/**
1040		* Ejecuta un SELECT DISTINCT
1041		* @param string $what
1042		* @return array
1043		*
1044		* Soporta parametros iguales a find
1045		**/
1046		public function distinct($what=''){
1047		$this->_connect();
1048		$what = get_params(func_get_args());
1049
1050		if($this->schema){
1051		$table = $this->schema.".".$this->source;
1052		} else {
1053		$table = $this->source;
1054		}
1055
1056		if(!isset($what['columns'])){
1057		$what['columns'] = $what['0'];
1058		} else {
1059		if(!$what['columns']) {
1060		$what['columns'] = $what['0'];
1061		}
1062		}
1063		$what['columns'] = ActiveRecord::sql_sanizite($what['columns']);
1064
1065		$select = "SELECT DISTINCT {$what['columns']} FROM $table ";
1066
1067		/**
1068		* Se elimina el de indice cero ya que por defecto convert_params_to_sql lo considera como una condicion en WHERE
1069		*/
1070		unset($what[0]);
1071		$select.= $this->convert_params_to_sql($what);
1072
1073		$results = array();
1074		foreach($this->db->fetch_all($select) as $result){
1075		$results[] = $result[0];
1076		}
1077		return $results;
1078		}
1079
1080		/**
1081		* Ejecuta una consulta en el RDBM directamente
1082		*
1083		* @param string $sql
1084		* @return resource
1085		*/
1086		public function select_one($sql){
1087		$this->_connect();
1088		if(substr(ltrim($sql), 0, 7)!="SELECT") {
1089		$sql = "SELECT ".$sql;
1090		}
1091		$num = $this->db->fetch_one($sql);
1092		return $num[0];
1093		}
1094
1095		static public function static_select_one($sql){
1096		$db = db::raw_connect();
1097		if(substr(ltrim($sql), 0, 7)!="SELECT") {
1098		$sql = "SELECT ".$sql;
1099		}
1100		$num = $db->fetch_one($sql);
1101		return $num[0];
1102		}
1103
1104		/**
1105		* Realiza un conteo de filas
1106		*
1107		* @param string $what
1108		* @return integer
1109		*/
1110		public function count($what=''){
1111		$this->_connect();
1112		$what = get_params(func_get_args());
1113
1114		if($this->schema){
1115		$table = "{$this->schema}.{$this->source}";
1116		} else {
1117		$table = $this->source;
1118		}
1119
1120		if(isset($what['distinct'])&&$what['distinct']) {
1121		if(isset($what['group']) \|\| isset($what['order'])) {
1122		$select = "SELECT COUNT(*) FROM (SELECT DISTINCT {$what['distinct']} FROM $table " ;
1123		$select.=$this->convert_params_to_sql($what);
1124		$select.=') AS t ';
1125		} else {
1126		$select = "SELECT COUNT(DISTINCT {$what['distinct']}) FROM $table " ;
1127		$select.=$this->convert_params_to_sql($what);
1128		}
1129		} else {
1130		$select = "SELECT COUNT(*) FROM $table " ;
1131		$select.=$this->convert_params_to_sql($what);
1132		}
1133
1134		$num = $this->db->fetch_one($select);
1135		return $num[0];
1136		}
1137
1138		/**
1139		* Realiza un promedio sobre el campo $what
1140		*
1141		* @param string $what
1142		* @return array
1143		*/
1144		public function average($what=''){
1145		$this->_connect();
1146		$what = get_params(func_get_args());
1147		if(isset($what['column'])) {
1148		if(!$what['column']){
1149		$what['column'] = $what[0];
1150		}
1151		} else {
1152		$what['column'] = $what[0];
1153		}
1154		unset($what[0]);
1155
1156		ActiveRecord::sql_item_sanizite($what['column']);
1157		if($this->schema){
1158		$table = "{$this->schema}.{$this->source}";
1159		} else {
1160		$table = $this->source;
1161		}
1162		$select = "SELECT AVG({$what['column']}) FROM $table " ;
1163		$select.=$this->convert_params_to_sql($what);
1164
1165		$num = $this->db->fetch_one($select);
1166		return $num[0];
1167		}
1168
1169		public function sum($what=''){
1170		$this->_connect();
1171		$what = get_params(func_get_args());
1172		if(isset($what['column'])) {
1173		if(!$what['column']){
1174		$what['column'] = $what[0];
1175		}
1176		} else {
1177		$what['column'] = $what[0];
1178		}
1179		unset($what[0]);
1180
1181		ActiveRecord::sql_item_sanizite($what['column']);
1182		if($this->schema){
1183		$table = "{$this->schema}.{$this->source}";
1184		} else {
1185		$table = $this->source;
1186		}
1187		$select = "SELECT SUM({$what['column']}) FROM $table " ;
1188		$select.=$this->convert_params_to_sql($what);
1189
1190		$num = $this->db->fetch_one($select);
1191		return $num[0];
1192		}
1193
1194		/**
1195		* Busca el valor maximo para el campo $what
1196		*
1197		* @param string $what
1198		* @return mixed
1199		*/
1200		public function maximum($what=''){
1201		$this->_connect();
1202		$what = get_params(func_get_args());
1203		if(isset($what['column'])) {
1204		if(!$what['column']){
1205		$what['column'] = $what[0];
1206		}
1207		} else {
1208		$what['column'] = $what[0];
1209		}
1210		unset($what[0]);
1211
1212		ActiveRecord::sql_item_sanizite($what['column']);
1213		if($this->schema){
1214		$table = "{$this->schema}.{$this->source}";
1215		} else {
1216		$table = $this->source;
1217		}
1218		$select = "SELECT MAX({$what['column']}) FROM $table " ;
1219		$select.=$this->convert_params_to_sql($what);
1220
1221		$num = $this->db->fetch_one($select);
1222		return $num[0];
1223		}
1224
1225		/**
1226		* Busca el valor minimo para el campo $what
1227		*
1228		* @param string $what
1229		* @return mixed
1230		*/
1231		public function minimum($what=''){
1232		$this->_connect();
1233		$what = get_params(func_get_args());
1234		if(isset($what['column'])) {
1235		if(!$what['column']){
1236		$what['column'] = $what[0];
1237		}
1238		} else {
1239		$what['column'] = $what[0];
1240		}
1241		unset($what[0]);
1242
1243		ActiveRecord::sql_item_sanizite($what['column']);
1244		if($this->schema){
1245		$table = "{$this->schema}.{$this->source}";
1246		} else {
1247		$table = $this->source;
1248		}
1249		$select = "SELECT MIN({$what['column']}) FROM $table " ;
1250		$select.=$this->convert_params_to_sql($what);
1251
1252		$num = $this->db->fetch_one($select);
1253		return $num[0];
1254		}
1255
1256		/**
1257		* Realiza un conteo directo mediante $sql
1258		*
1259		* @param string $sqlQuery
1260		* @return mixed
1261		*/
1262		public function count_by_sql($sqlQuery){
1263		$this->_connect();
1264		$num = $this->db->fetch_one($sqlQuery);
1265		return $num[0];
1266		}
1267
1268		/**
1269		* Iguala los valores de un resultado de la base de datos
1270		* en un nuevo objeto con sus correspondientes
1271		* atributos de la clase
1272		*
1273		* @param array $result
1274		* @return ActiveRecord
1275		*/
1276		function dump_result($result){
1277		$this->_connect();
1278		$obj = clone $this;
1279		/**
1280		* Consulta si la clase es padre de otra y crea el tipo de dato correcto
1281		*/
1282		if(isset($result['type'])){
1283		if(in_array($result['type'], $this->parent_of)){
1284		if(class_exists($result['type'])){
1285		$obj = new $result['type'];
1286		unset($result['type']);
1287		}
1288		}
1289		}
1290		$this->_dump_lock = true;
1291		if(is_array($result)){
1292		foreach($result as $k => $r){
1293		if(!is_numeric($k)){
1294		$obj->$k = stripslashes($r);
1295		}
1296		}
1297		}
1298		$this->_dump_lock = false;
1299		return $obj;
1300		}
1301
1302		/**
1303		* Iguala los valores de un resultado de la base de datos
1304		* con sus correspondientes atributos de la clase
1305		*
1306		* @param array $result
1307		* @return ActiveRecord
1308		*/
1309		public function dump_result_self($result){
1310		$this->_connect();
1311		$this->_dump_lock = true;
1312		if(is_array($result)){
1313		foreach($result as $k => $r){
1314		if(!is_numeric($k)){
1315		$this->$k = stripslashes($r);
1316		}
1317		}
1318		}
1319		$this->_dump_lock = false;
1320		}
1321
1322		/**
1323		* Create a new Row using values from $_REQUEST
1324		*
1325		* @param string $form form name for request, equivalent to $_REQUEST[$form]
1326		* @return boolean success
1327		*/
1328		public function create_from_request($form=''){
1329		if($form) {
1330		return $this->create($_REQUEST[$form]);
1331		} else {
1332		return $this->create($_REQUEST);
1333		}
1334		}
1335
1336		/**
1337		* Saves a new Row using values from $_REQUEST
1338		*
1339		* @param string $form form name for request, equivalent to $_REQUEST[$form]
1340		* @return boolean success
1341		*/
1342		public function save_from_request($form=''){
1343		if($form) {
1344		return $this->save($_REQUEST[$form]);
1345		} else {
1346		return $this->save($_REQUEST);
1347		}
1348		}
1349
1350
1351		/**
1352		* Updates a Row using values from $_REQUEST
1353		*
1354		* @param string $form form name for request, equivalent to $_REQUEST[$form]
1355		* @return boolean success
1356		*/
1357		public function update_from_request($form=''){
1358		if($form) {
1359		return $this->update($_REQUEST[$form]);
1360		} else {
1361		return $this->update($_REQUEST);
1362		}
1363		}
1364
1365		/**
1366		* Creates a new Row in map table
1367		*
1368		* @param mixed $values
1369		* @return success boolean
1370		*/
1371		public function create(){
1372		$this->_connect();
1373
1374		if(func_num_args()>0){
1375		$params = get_params(func_get_args());
1376		$values = (isset($params[0]) && is_array($params[0])) ? $params[0]: $params;
1377		foreach($this->fields as $field) {
1378		if(isset($values[$field])) {
1379		$this->$field = $values[$field];
1380		}
1381		}
1382		}
1383		if($this->primary_key[0]=='id'){
1384		$this->id = null;
1385		}
1386
1387		return $this->save();
1388		}
1389
1390		/**
1391		* Consulta si un determinado registro existe o no
1392		* en la entidad de la base de datos
1393		*
1394		* @return boolean
1395		*/
1396		function exists($where_pk=''){
1397		$this->_connect();
1398		if($this->schema){
1399		$table = "{$this->schema}.{$this->source}";
1400		} else {
1401		$table = $this->source;
1402		}
1403		if(!$where_pk){
1404		$where_pk = array();
1405		foreach($this->primary_key as $key){
1406		if($this->$key){
1407		$where_pk[] = " $key = '{$this->$key}'";
1408		}
1409		}
1410		if(count($where_pk)){
1411		$this->_where_pk = join(" AND ", $where_pk);
1412		} else {
1413		return 0;
1414		}
1415		$query = "SELECT COUNT(*) FROM $table WHERE {$this->_where_pk}";
1416		} else {
1417		if(is_numeric($where_pk)){
1418		$query = "SELECT(*) FROM $table WHERE id = '$where_pk'";
1419		} else {
1420		$query = "SELECT COUNT(*) FROM $table WHERE $where_pk";
1421		}
1422		}
1423		$num = $this->db->fetch_one($query);
1424		return $num[0];
1425		}
1426
1427		/**
1428		* Saves Information on the ActiveRecord Properties
1429		* @param array $values array de valores a cargar
1430		* @return boolean success
1431		*/
1432		public function save(){
1433		$this->_connect();
1434
1435		if(func_num_args()>0){
1436		$params = get_params(func_get_args());
1437		$values = (isset($params[0]) && is_array($params[0])) ? $params[0]: $params;
1438		foreach($this->fields as $field) {
1439		if(isset($values[$field])) {
1440		$this->$field = $values[$field];
1441		}
1442		}
1443		}
1444
1445		$ex = $this->exists();
1446
1447		if($this->schema){
1448		$table = $this->schema.".".$this->source;
1449		} else {
1450		$table = $this->source;
1451		}
1452
1453		#Run Validation Callbacks Before
1454		if(method_exists($this, 'before_validation')){
1455		if($this->before_validation()=='cancel') {
1456		return false;
1457		}
1458		} else {
1459		if(isset($this->before_validation)){
1460		$method = $this->before_validation;
1461		if($this->$method()=='cancel') {
1462		return false;
1463		}
1464		}
1465		}
1466		if(!$ex&&method_exists($this, "before_validation_on_create")){
1467		if($this->before_validation_on_create()=='cancel') {
1468		return false;
1469		}
1470		} else {
1471		if(isset($this->before_validation_on_create)){
1472		$method = $this->before_validation_on_create;
1473		if($this->$method()=='cancel') {
1474		return false;
1475		}
1476		}
1477		}
1478		if($ex&&method_exists($this, "before_validation_on_update")){
1479		if($this->before_validation_on_update()=='cancel') {
1480		return false;
1481		}
1482		} else {
1483		if(isset($this->before_validation_on_update)){
1484		$method = $this->before_validation_on_update;
1485		if($this->$method()=='cancel') {
1486		return false;
1487		}
1488		}
1489		}
1490
1491		/**
1492		* Recordamos que aqui no aparecen los que tienen valores por defecto,
1493		* pero sin embargo se debe estar pendiente de validar en las otras verificaciones
1494		* los campos nulos, ya que en estas si el campo es nulo, realmente se refiere a un campo que
1495		* debe tomar el valor por defecto
1496		**/
1497		$e = false;
1498		for($i=0;$i<=count($this->not_null)-1;$i++){
1499		$f = $this->not_null[$i];
1500		if(isset($this->$f) && (is_null($this->$f)\|\|$this->$f=='')){
1501		if(!$ex&&$f=='id'){
1502		continue;
1503		}
1504		if(!$ex&&in_array($f, $this->_at)){
1505		continue;
1506		}
1507		if($ex&&in_array($f, $this->_in)){
1508		continue;
1509		}
1510		Flash::error("Error: El campo $f no puede ser nulo");
1511		$e = true;
1512		}
1513		}
1514		if($e){
1515		return false;
1516		}
1517
1518		/**
1519		* Validacion validates_presence
1520		**/
1521		$e = false;
1522		foreach($this->_validates_presence as $f=>$opt){
1523		$f = $this->not_null[$i];
1524		if(isset($this->$f) && (is_null($this->$f)\|\|$this->$f=='')){
1525		if(!$ex&&$f=='id'){
1526		continue;
1527		}
1528		if(!$ex&&in_array($f, $this->_at)){
1529		continue;
1530		}
1531		if($ex&&in_array($f, $this->_in)){
1532		continue;
1533		}
1534
1535		if(isset($opt['message'])) {
1536		Flash::error($opt['message']);
1537		} else {
1538		$field = isset($opt['field']) ? $opt['field'] : $f;
1539		Flash::error("Error: El campo $field no puede ser nulo");
1540		}
1541		$e = true;
1542		}
1543		}
1544		if($e){
1545		return false;
1546		}
1547
1548		/**
1549		* Validacion validates_length
1550		**/
1551		$e = false;
1552		foreach($this->_validates_length as $f => $opt){
1553		if(isset($this->$f) && !is_null($this->$f) && $this->$f!='') {
1554		$field = isset($opt['field']) ? $opt['field'] : $f;
1555
1556		if(isset($opt['in'])){
1557		$in = explode(":", $opt['in']);
1558		if(is_numeric($in[0])&&is_numeric($in[1])){
1559		$opt['minimum'] = $in[0];
1560		$opt['maximum'] = $in[1];
1561		}
1562		}
1563		if(isset($opt['minimum']) && is_numeric($opt['minimum'])){
1564		$n = $opt['minimum'];
1565		if(strlen($this->$f)<$n){
1566		if(!isset($opt['too_short'])){
1567		Flash::error("Error: El campo $field debe tener como mínimo $n caracteres");
1568		$e = true;
1569		} else {
1570		Flash::error($opt['too_short']);
1571		$e = true;
1572		}
1573		}
1574		}
1575		if(isset($opt['maximum']) && is_numeric($opt['maximum'])){
1576		$n = $opt['maximum'];
1577		if(strlen($this->$f)>$n){
1578		if(!isset($opt['too_long'])){
1579		Flash::error("Error: El campo $field debe tener como máximo $n caracteres");
1580		$e = true;
1581		} else {
1582		Flash::error($opt['too_long']);
1583		$e = true;
1584		}
1585		}
1586		}
1587		}
1588		}
1589		if($e){
1590		return false;
1591		}
1592
1593		/**
1594		* Validacion validates_inclusion
1595		**/
1596		$e = false;
1597		foreach($this->_validates_inclusion as $finc => $list){
1598		if(isset($this->$finc) && !is_null($this->$finc) && $this->$finc!='') {
1599		if(!is_array($list[1]) && $this->$finc!=$list[1]){
1600		if(isset($list['message'])) {
1601		Flash::error($list['message']);
1602		} else {
1603		$field = isset($list['field']) ? $list['field'] : ucwords($finc);
1604		Flash::error("$field debe tener un valor entre ({$list[1]})");
1605		}
1606		$e = true;
1607		} else {
1608		if(!in_array($this->$finc, $list[1])){
1609		if(isset($list['message'])) {
1610		Flash::error($list['message']);
1611		} else {
1612		$field = isset($list['field']) ? $list['field'] : ucwords($finc);
1613		Flash::error("$field debe tener un valor entre (".join(",", $list[1]).")");
1614		}
1615		$e = true;
1616		}
1617		}
1618		}
1619		}
1620		if($e){
1621		return false;
1622		}
1623
1624		/**
1625		* Validacion validates_exclusion
1626		**/
1627		$e = false;
1628		foreach($this->_validates_exclusion as $finc => $list){
1629		if(isset($this->$finc) && !is_null($this->$finc) && $this->$finc!='') {
1630		if(!is_array($list[1]) && $this->$finc==$list[1]){
1631		if(isset($list['message'])) {
1632		Flash::error($list['message']);
1633		} else {
1634		$field = isset($list['field']) ? $list['field'] : ucwords($finc);
1635		Flash::error("$field no debe tener un valor entre ({$list[1]})");
1636		}
1637		$e = true;
1638		} else {
1639		if(in_array($this->$finc, $list[1])){
1640		if(isset($list['message'])) {
1641		Flash::error($list['message']);
1642		} else {
1643		$field = isset($list['field']) ? $list['field'] : ucwords($finc);
1644		Flash::error("$field no debe tener un valor entre (".join(",", $list[1]).")");
1645		}
1646		$e = true;
1647		}
1648		}
1649		}
1650		}
1651		if($e){
1652		return false;
1653		}
1654
1655		/**
1656		* Validacion validates_numericality
1657		**/
1658		$e = false;
1659		foreach($this->_validates_numericality as $fnum=>$opt){
1660		if(isset($this->$fnum) && !is_null($this->$fnum) && $this->$fnum!='') {
1661		if(!is_numeric($this->$fnum)){
1662		if(isset($opt['message'])) {
1663		Flash::error($opt['message']);
1664		} else {
1665		$field = isset($opt['field']) ? $opt['field'] : ucwords($fnum);
1666		Flash::error("$field debe tener un valor numérico");
1667		}
1668		$e = true;
1669		}
1670		}
1671		}
1672		if($e){
1673		return false;
1674		}
1675
1676		/**
1677		* Validacion validates_format
1678		**/
1679		$e = false;
1680		foreach($this->_validates_format as $fkey => $opt){
1681		if(isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey!='') {
1682		if(!ereg($opt[1], $this->$fkey)){
1683		if(isset($opt['message'])) {
1684		Flash::error($opt['message']);
1685		} else {
1686		$field = isset($opt['field']) ? $opt['field'] : $fkey;
1687		Flash::error("Formato erroneo para $field");
1688		}
1689		$e = true;
1690		}
1691		}
1692		}
1693		if($e){
1694		return false;
1695		}
1696
1697		/**
1698		* Validacion validates_date
1699		**/
1700		$e = false;
1701		foreach($this->_validates_date as $fkey=>$opt){
1702		if(isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey!='') {
1703		if(!ereg("^[0-9]{4}[-/](0[1-9]\|1[12])[-/](0[1-9]\|[12][0-9]\|3[01])$", $this->$fkey, $regs)){
1704		if(isset($opt['message'])) {
1705		Flash::error($opt['message']);
1706		} else {
1707		$field = isset($opt['field']) ? $opt['field'] : $fkey;
1708		Flash::error("Formato de fecha ({$this->$fkey}) erroneo para $field");
1709		}
1710		$e = true;
1711		}
1712		}
1713		}
1714		if($e){
1715		return false;
1716		}
1717
1718		/**
1719		* Validacion validates_email
1720		**/
1721		$e = false;
1722		foreach($this->_validates_email as $fkey){
1723		if(isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey!='') {
1724		if(!ereg("^[a-zA-Z0-9_\.\+]+@[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*$", $this->$fkey, $regs)){
1725		if(isset($opt['message'])) {
1726		Flash::error($opt['message']);
1727		} else {
1728		$field = isset($opt['field']) ? $opt['field'] : $fkey;
1729		Flash::error("Formato de e-mail erroneo en el campo $field");
1730		}
1731		$e = true;
1732		}
1733		}
1734		}
1735		if($e){
1736		return false;
1737		}
1738
1739		/**
1740		* Validacion validates_uniqueness
1741		**/
1742		$e = false;
1743		foreach($this->_validates_uniqueness as $fkey => $opt){
1744		ActiveRecord::sql_item_sanizite($fkey);
1745		if(isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey!='') {
1746		if($ex){
1747		$copy = clone $this;
1748		$copy->find_first("$fkey = {$this->db->add_quotes($this->$fkey)}");
1749		$number = $this->db->fetch_one("SELECT COUNT(*) FROM $table WHERE $fkey = {$this->db->add_quotes($this->$fkey)} and $fkey <> {$this->db->add_quotes($copy->$fkey)}");
1750		} else {
1751		$number = $this->db->fetch_one("SELECT COUNT(*) FROM $table WHERE $fkey = {$this->db->add_quotes($this->$fkey)}");
1752		}
1753		if((int) $number[0]){
1754		if(isset($opt['message'])) {
1755		Flash::error($opt['message']);
1756		} else {
1757		$field = isset($opt['field']) ? $opt['field'] : $fkey;
1758		Flash::error("El valor '{$this->$fkey}' ya existe para el campo $field");
1759		}
1760		$e = true;
1761		}
1762		}
1763		}
1764		if($e){
1765		return false;
1766		}
1767
1768
1769		#Run Validation Callbacks After
1770		if(!$ex&&method_exists($this, "after_validation_on_create")){
1771		if($this->after_validation_on_create()=='cancel') {
1772		return false;
1773		}
1774		} else {
1775		if(isset($this->after_validation_on_create)){
1776		$method = $this->after_validation_on_create;
1777		if($this->$method()=='cancel') {
1778		return false;
1779		}
1780		}
1781		}
1782		if($ex&&method_exists($this, "after_validation_on_update")){
1783		if($this->after_validation_on_update()=='cancel') {
1784		return false;
1785		}
1786		} else {
1787		if(isset($this->after_validation_on_update)){
1788		$method = $this->after_validation_on_update;
1789		if($this->$method()=='cancel') return false;
1790		}
1791		}
1792		if(method_exists($this, 'after_validation')){
1793		if($this->after_validation()=='cancel') {
1794		return false;
1795		}
1796		} else {
1797		if(isset($this->after_validation)){
1798		$method = $this->after_validation;
1799		if($this->$method()=='cancel') {
1800		return false;
1801		}
1802		}
1803		}
1804		# Run Before Callbacks
1805		if(method_exists($this, "before_save")){
1806		if($this->before_save()=='cancel') {
1807		return false;
1808		}
1809		} else {
1810		if(isset($this->before_save)){
1811		$method = $this->before_save;
1812		if($this->$method()=='cancel') {
1813		return false;
1814		}
1815		}
1816		}
1817		if($ex&&method_exists($this, "before_update")){
1818		if($this->before_update()=='cancel') {
1819		return false;
1820		}
1821		} else {
1822		if(isset($this->before_update)){
1823		$method = $this->before_update;
1824		if($this->$method()=='cancel') {
1825		return false;
1826		}
1827		}
1828		}
1829		if(!$ex&&method_exists($this, "before_create")){
1830		if($this->before_create()=='cancel') {
1831		return false;
1832		}
1833		} else {
1834		if(isset($this->before_create)){
1835		$method = $this->before_create;
1836		if($this->$method()=='cancel') {
1837		return false;
1838		}
1839		}
1840		}
1841
1842		$environment = Config::read("environment.ini");
1843		$config = $environment->{$this->get_mode()};
1844		if($ex){
1845		$fields = array();
1846		$values = array();
1847		foreach($this->non_primary as $np){
1848		$np = ActiveRecord::sql_item_sanizite($np);
1849		if(in_array($np, $this->_in)){
1850		if($config->database->type=='oracle'){
1851		$this->$np = date("Y-m-d");
1852		} else {
1853		$this->$np = date("Y-m-d G:i:s");
1854		}
1855		}
1856
1857		if(isset($this->$np)) {
1858		$fields[] = $np;
1859		if(is_null($this->$np) \|\| $this->$np==''){
1860		$values[] = "NULL";
1861		} elseif(substr($this->$np, 0, 1)=="%"){
1862		$values[] = str_replace("%", "", $this->$np);
1863		} else {
1864		/**
1865		* Se debe especificar el formato de fecha en Oracle
1866		*/
1867		if($this->_data_type[$np]=='date'&&$config->database->type=='oracle'){
1868		$values[] = "TO_DATE(".$this->db->add_quotes($this->$np).", 'YYYY-MM-DD')";
1869		} else {
1870		$values[] = $this->db->add_quotes($this->$np);
1871		}
1872		}
1873		}
1874		}
1875		$val = $this->db->update($table, $fields, $values, $this->_where_pk);
1876		} else {
1877		$fields = array();
1878		$values = array();
1879		foreach($this->fields as $field){
1880		if($field!='id'&&!$this->id){
1881		if(in_array($field, $this->_at)){
1882		if($config->database->type=='oracle'){
1883		$this->$field = date("Y-m-d");
1884		} else {
1885		$this->$field = date("Y-m-d G:i:s");
1886		}
1887		}
1888
1889		if(in_array($field, $this->_in)){
1890		unset($this->$field);
1891		}
1892
1893		$use_default = in_array($field, $this->_with_default) && isset($this->$field) && (is_null($this->$field) \|\| $this->$field=='');
1894		if(isset($this->$field) && !$use_default) {
1895		$fields[] = ActiveRecord::sql_sanizite($field);
1896		if(substr($this->$field, 0, 1)=="%"){
1897		$values[] = str_replace("%", "", $this->$field);
1898		} else {
1899		if($this->is_a_numeric_type($field)\|\|$this->$field==null){
1900		$values[] = addslashes($this->$field!==''&&$this->$field!==null ? $this->$field : "NULL");
1901		} else {
1902		if($this->_data_type[$field]=='date'&&$config->database->type=='oracle'){
1903		/**
1904		* Se debe especificar el formato de fecha en Oracle
1905		*/
1906		$values[] = "TO_DATE(".$this->db->add_quotes($this->$field).", 'YYYY-MM-DD')";
1907		} else {
1908		if(!is_null($this->$field) && $this->$field!=''){
1909		$values[] = $this->db->add_quotes($this->$field);
1910		} else {
1911		$values[] = "NULL";
1912		}
1913		}
1914		}
1915		}
1916		}
1917		} else {
1918		/**
1919		* Campos autonumericos en Oracle deben utilizar una sequencia auxiliar
1920		*/
1921		if($config->database->type=='oracle'){
1922		if(!$this->id){
1923		$fields[] = "id";
1924		$values[] = $this->source."_id_seq.NEXTVAL";
1925		}
1926		}
1927		if($config->database->type=='informix'){
1928		if(!$this->id){
1929		$fields[] = "id";
1930		$values[] = 0;
1931		}
1932		}
1933		}
1934		}
1935		$val = $this->db->insert($table, $values, $fields);
1936		}
1937
1938		if(!isset($config->database->pdo)&&$config->database->type=='oracle'){
1939		$this->commit();
1940		}
1941
1942		if(!$ex){
1943		$this->db->logger = true;
1944		$m = $this->db->last_insert_id($table, $this->primary_key[0]);
1945		$this->find_first($m);
1946		}
1947
1948		if($val){
1949		if($ex&&method_exists($this, "after_update")){
1950		if($this->after_update()=='cancel') {
1951		return false;
1952		}
1953		} else {
1954		if(isset($this->after_update)){
1955		$method = $this->after_update;
1956		if($this->$method()=='cancel') {
1957		return false;
1958		}
1959		}
1960		}
1961		if(!$ex&&method_exists($this, "after_create")){
1962		if($this->after_create()=='cancel') {
1963		return false;
1964		}
1965		} else {
1966		if(isset($this->after_create)){
1967		$method = $this->after_create;
1968		if($this->$method()=='cancel') {
1969		return false;
1970		}
1971		}
1972		}
1973		if(method_exists($this, "after_save")){
1974		if($this->after_save()=='cancel') {
1975		return false;
1976		}
1977		} else {
1978		if(isset($this->after_save)){
1979		$method = $this->after_save;
1980		if($this->$method()=='cancel') {
1981		return false;
1982		}
1983		}
1984		}
1985		return $val;
1986		} else {
1987		return false;
1988		}
1989		}
1990
1991		/**
1992		* Find All data in the Relational Table
1993		*
1994		* @param string $field
1995		* @param string $value
1996		* @return ActiveRecod Cursor
1997		*/
1998		function find_all_by($field, $value){
1999		ActiveRecord::sql_item_sanizite($field);
2000		return $this->find("conditions: $field = {$this->db->add_quotes($value)}");
2001		}
2002
2003		/**
2004		* Updates Data in the Relational Table
2005		*
2006		* @param mixed $values
2007		* @return boolean sucess
2008		*/
2009		function update(){
2010		$this->_connect();
2011		if(func_num_args()>0){
2012		$params = get_params(func_get_args());
2013		$values = (isset($params[0]) && is_array($params[0])) ? $params[0]: $params;
2014		foreach($this->fields as $field) {
2015		if(isset($values[$field])) {
2016		$this->$field = $values[$field];
2017		}
2018		}
2019		}
2020
2021		if($this->exists()){
2022		return $this->save();
2023		} else {
2024		Flash::error('No se puede actualizar porque el registro no existe');
2025		return false;
2026		}
2027		}
2028
2029		/**
2030		* Deletes data from Relational Map Table
2031		*
2032		* @param mixed $what
2033		*/
2034		function delete($what=''){
2035		$this->_connect();
2036		if(func_num_args()>1){
2037		$what = get_params(func_get_args());
2038		}
2039		if($this->schema){
2040		$table = $this->schema.".".$this->source;
2041		} else {
2042		$table = $this->source;
2043		}
2044		$conditions = "";
2045		if(is_array($what)){
2046		if($what["conditions"]) {
2047		$conditions = $what["conditions"];
2048		}
2049		} else {
2050		if(is_numeric($what)){
2051		ActiveRecord::sql_sanizite($this->primary_key[0]);
2052		$conditions = "{$this->primary_key[0]} = '$what'";
2053		} else{
2054		if($what){
2055		$conditions = $what;
2056		} else {
2057		ActiveRecord::sql_sanizite($this->primary_key[0]);
2058		$conditions = "{$this->primary_key[0]} = '{$this->{$this->primary_key[0]}}'";
2059		}
2060		}
2061		}
2062		if(method_exists($this, "before_delete")){
2063		if($this->id) {
2064		$this->find($this->id);
2065		}
2066		if($this->before_delete()=='cancel') {
2067		return false;
2068		}
2069		} else {
2070		if(isset($this->before_delete)){
2071		if($this->id) {
2072		$this->find($this->id);
2073		}
2074		$method = $this->before_delete;
2075		if($this->$method()=='cancel') {
2076		return false;
2077		}
2078		}
2079		}
2080		$val = $this->db->delete($table, $conditions);
2081		if($val){
2082		if(method_exists($this, "after_delete")){
2083		if($this->after_delete()=='cancel') {
2084		return false;
2085		}
2086		} else {
2087		if(isset($this->after_delete)){
2088		$method = $this->after_delete;
2089		if($this->$method()=='cancel') {
2090		return false;
2091		}
2092		}
2093		}
2094		}
2095		return $val;
2096		}
2097
2098		/**
2099		* Actualiza todos los atributos de la entidad
2100		* $Clientes->update_all("estado='A', fecha='2005-02-02'", "id>100");
2101		* $Clientes->update_all("estado='A', fecha='2005-02-02'", "id>100", "limit: 10");
2102		*
2103		* @param string $values
2104		*/
2105		function update_all($values){
2106		$this->_connect();
2107		$params = array();
2108		if($this->schema){
2109		$table = $this->schema.".".$this->source;
2110		} else {
2111		$table = $this->source;
2112		}
2113		if(func_num_args()>1){
2114		$params = get_params(func_get_args());
2115		}
2116		if(!isset($params['conditions'])\|\|!$params['conditions']){
2117		if(isset($params[1])){
2118		$params['conditions'] = $params[1];
2119		} else {
2120		$params['conditions'] = "";
2121		}
2122		}
2123		if($params['conditions']){
2124		$params['conditions'] = " WHERE ".$params['conditions'];
2125		}
2126		$sql = "UPDATE $table SET $values {$params['conditions']}";
2127
2128		$limit_args = array($sql);
2129		if(isset($params['limit'])) {
2130		array_push($limit_args, "limit: $params[limit]");
2131		}
2132		if(isset($params['offset'])) {
2133		array_push($limit_args, "offset: $params[offset]");
2134		}
2135		if(count($limit_args)>1) {
2136		$sql = call_user_func_array(array($this,'limit'), $limit_args);
2137		}
2138
2139		$environment = Config::read("environment.ini");
2140		$config = $environment->{$this->get_mode()};
2141		if(!isset($config->database->pdo)\|\|!$config->database->pdo){
2142		if($config->database->type=="informix"){
2143		$this->db->set_return_rows(false);
2144		}
2145		}
2146		return $this->db->query($sql);
2147		}
2148
2149		/**
2150		* Delete All data from Relational Map Table
2151		*
2152		* @param string $conditions
2153		* @return boolean
2154		*/
2155		function delete_all($conditions=''){
2156		$this->_connect();
2157		$limit = "";
2158		if($this->schema){
2159		$table = $this->schema.".".$this->source;
2160		} else {
2161		$table = $this->source;
2162		}
2163		if(func_num_args()>1){
2164		$params = get_params(func_get_args());
2165
2166		$limit_args = array($select);
2167		if(isset($params['limit'])) {
2168		array_push($limit_args, "limit: $params[limit]");
2169		}
2170		if(isset($params['offset'])) {
2171		array_push($limit_args, "offset: $params[offset]");
2172		}
2173		if(count($limit_args)>1) {
2174		$select = call_user_func_array(array($this,'limit'), $limit_args);
2175		}
2176		}
2177		return $this->db->delete($table, $conditions);
2178		}
2179
2180		/**
2181		* *********************************************************************************
2182		* Metodos de Debug
2183		* *********************************************************************************
2184		*/
2185
2186		/**
2187		* Imprime una version humana de los valores de los campos
2188		* del modelo en una sola linea
2189		*
2190		*/
2191		public function inspect(){
2192		$this->_connect();
2193		$inspect = array();
2194		foreach($this->fields as $field){
2195		if(!is_array($field)){
2196		$inspect[] = "$field: {$this->$field}";
2197		}
2198		}
2199		return join(", ", $inspect);
2200		}
2201
2202		/**
2203		* *********************************************************************************
2204		* Metodos de Validacion
2205		* *********************************************************************************
2206		*/
2207
2208		/**
2209		* Validate that Attributes cannot have a NULL value
2210		*/
2211		protected function validates_presence_of(){
2212		$this->_connect();
2213
2214		$params = get_params(func_get_args());
2215		if(is_array($params[0])) {
2216		$params = $params[0];
2217		}
2218
2219		$fields = array();
2220		for($i=0; isset($params[$i]); $i++) {
2221		$fields[] = $params[$i];
2222		unset($params[$i]);
2223		$i++;
2224		}
2225
2226		foreach($fields as $p){
2227		if(!in_array($p, $this->fields)&&!isset($this->$p)){
2228		throw new ActiveRecordException('No se puede validar presencia de "'.$p.'"
2229		en el modelo '.$this->source.' porque no existe el atributo</u><br>
	579	} else {
	580	return array();
	581	}
	582	}
	583	}
	584	try {
	585	if (method_exists($this, $method)) {
	586	call_user_func_array(array($this, $method), $args);
	587	} else {
	588	if ($has_relation) {
	589	throw new ActiveRecordException("No existe el modelo '$model' para relacionar con ActiveRecord::{$this->source}");
	590	} else {
	591	throw new ActiveRecordException("No existe el método '$method' en ActiveRecord::" . get_class($this));
	592	}
	593	}
	594	}
	595	catch(Exception $e) {
	596	$this->exceptions($e);
	597	}
	598	return $this->$method($args);
	599	}
	600	/**
	601	* Se conecta a la base de datos y descarga los meta-datos si es necesario
	602	*
	603	* @param boolean $new_connection
	604	*/
	605	private function _connect($new_connection = false) {
	606	if (!is_object($this->db) \|\| $new_connection) {
	607	if ($this->mode) {
	608	$this->db = DbBase::raw_connect($new_connection, "mode: {$this->mode}");
	609	} else {
	610	$this->db = DbBase::raw_connect($new_connection);
	611	}
	612	}
	613	$this->db->debug = $this->debug;
	614	$this->db->logger = $this->logger;
	615	$this->dump();
	616	}
	617	/**
	618	* Cargar los metadatos de la tabla
	619	*
	620	*/
	621	public function dump_model() {
	622	$this->_connect();
	623	}
	624	/**
	625	* Verifica si la tabla definida en $this->source existe
	626	* en la base de datos y la vuelca en dump_info
	627	*
	628	* @return boolean
	629	*/
	630	protected function dump() {
	631	if ($this->_dumped) {
	632	return false;
	633	}
	634	if ($this->source) {
	635	$this->source = str_replace(";", "", strtolower($this->source));
	636	} else {
	637	$this->_model_name();
	638	if (!$this->source) {
	639	return false;
	640	}
	641	}
	642	$table = $this->source;
	643	$schema = $this->schema;
	644	if (!count(ActiveRecord::get_meta_data($this->source))) {
	645	$this->_dumped = true;
	646	if ($this->db->table_exists($table, $schema)) {
	647	$this->_dump_info($table, $schema);
	648	} else {
	649	throw new ActiveRecordException("No existe la tabla '$table' en la base de datos");
	650	return false;
	651	}
	652	if (!count($this->primary_key)) {
	653	if (!$this->is_view) {
	654	throw new ActiveRecordException("No se ha definido una llave primaria para la tabla '$table' esto imposibilita crear el ActiveRecord para esta entidad");
	655	return false;
	656	}
	657	}
	658	} else {
	659	if (!$this->is_dumped()) {
	660	$this->_dumped = true;
	661	$this->_dump_info($table, $schema);
	662	}
	663	}
	664	return true;
	665	}
	666	/**
	667	* Vuelca la información de la tabla $table en la base de datos
	668	* para armar los atributos y meta-data del ActiveRecord
	669	*
	670	* @param string $table
	671	* @return boolean
	672	*/
	673	private function _dump_info($table, $schema = '') {
	674	$this->_dump_lock = true;
	675	if (!count(ActiveRecord::get_meta_data($table))) {
	676	$meta_data = $this->db->describe_table($table, $schema);
	677	if ($meta_data) {
	678	ActiveRecord::set_meta_data($table, $meta_data);
	679	}
	680	}
	681	foreach(ActiveRecord::get_meta_data($table) as $field) {
	682	$this->fields[] = $field['Field'];
	683	if ($field['Key'] == 'PRI') {
	684	$this->primary_key[] = $field['Field'];
	685	} else $this->non_primary[] = $field['Field'];
	686	/**
	687	* Si se indica que no puede ser nulo, pero se indica un
	688	* valor por defecto, entonces no se incluye en la lista, ya que
	689	* al colocar un valor por defecto, el campo nunca sera nulo
	690	*
	691	*/
	692	if ($field['Null'] == 'NO' && !(isset($field['Default']) && $field['Default'])) {
	693	$this->not_null[] = $field['Field'];
	694	}
	695	if (isset($field['Default']) && $field['Default']) {
	696	$this->_with_default[] = $field['Field'];
	697	}
	698	if ($field['Type']) {
	699	$this->_data_type[$field['Field']] = strtolower($field['Type']);
	700	}
	701	if (substr($field['Field'], strlen($field['Field']) - 3, 3) == '_at') {
	702	$this->_at[] = $field['Field'];
	703	}
	704	if (substr($field['Field'], strlen($field['Field']) - 3, 3) == '_in') {
	705	$this->_in[] = $field['Field'];
	706	}
	707	}
	708	$this->attributes_names = $this->fields;
	709	$this->_dump_lock = false;
	710	return true;
	711	}
	712	/**
	713	* Commit a Transaction
	714	*
	715	* @return success
	716	*/
	717	public function commit() {
	718	$this->_connect();
	719	return $this->db->commit();
	720	}
	721	/**
	722	* Rollback a Transaction
	723	*
	724	* @return success
	725	*/
	726	public function rollback() {
	727	$this->_connect();
	728	return $this->db->rollback();
	729	}
	730	/**
	731	* Start a transaction in RDBM
	732	*
	733	* @return success
	734	*/
	735	public function begin() {
	736	$this->_connect(true);
	737	return $this->db->begin();
	738	}
	739	/**
	740	* Find all records in this table using a SQL Statement
	741	*
	742	* @param string $sqlQuery
	743	* @return ActiveRecord Cursor
	744	*/
	745	public function find_all_by_sql($sqlQuery) {
	746	$this->_connect();
	747	$results = array();
	748	foreach($this->db->fetch_all($sqlQuery) as $result) {
	749	$results[] = $this->dump_result($result);
	750	}
	751	return $results;
	752	}
	753	/**
	754	* Find a record in this table using a SQL Statement
	755	*
	756	* @param string $sqlQuery
	757	* @return ActiveRecord Cursor
	758	*/
	759	public function find_by_sql($sqlQuery) {
	760	$this->_connect();
	761	$row = $this->db->fetch_one($sqlQuery);
	762	if ($row !== false) {
	763	$this->dump_result_self($row);
	764	return $this->dump_result($row);
	765	} else {
	766	return false;
	767	}
	768	}
	769	/**
	770	* Execute a SQL Statement directly
	771	*
	772	* @param string $sqlQuery
	773	* @return int affected
	774	*/
	775	public function sql($sqlQuery) {
	776	$this->_connect();
	777	return $this->db->query($sqlQuery);
	778	}
	779	/**
	780	* Return Fist Record
	781	*
	782	* @param mixed $what
	783	* @param boolean $debug
	784	*
	785	* Recibe los mismos parametros que find
	786	*
	787	* @return ActiveRecord Cursor
	788	*/
	789	public function find_first($what = '') {
	790	$this->_connect();
	791	$what = get_params(func_get_args());
	792	$select = "SELECT ";
	793	if (isset($what['columns'])) {
	794	$select.= ActiveRecord::sql_sanizite($what['columns']);
	795	} elseif (isset($what['distinct'])) {
	796	$select.= 'DISTINCT ';
	797	$select.= $what['distinct'] ? ActiveRecord::sql_sanizite($what['distinct']) : join(",", $this->fields);
	798	} else {
	799	$select.= join(",", $this->fields);
	800	}
	801	if ($this->schema) {
	802	$select.= " FROM {$this->schema}.{$this->source}";
	803	} else {
	804	$select.= " FROM {$this->source}";
	805	}
	806	$what['limit'] = 1;
	807	$select.= $this->convert_params_to_sql($what);
	808	$resp = false;
	809	try {
	810	$result = $this->db->fetch_one($select);
	811	if ($result) {
	812	$this->dump_result_self($result);
	813	$resp = $this->dump_result($result);
	814	}
	815	}
	816	catch(Exception $e) {
	817	$this->exceptions($e);
	818	}
	819	return $resp;
	820	}
	821	/**
	822	* Find data on Relational Map table
	823	*
	824	* @param string $what
	825	* @return ActiveRecord Cursor
	826	*
	827	* columns: columnas a utilizar
	828	* conditions : condiciones de busqueda en WHERE
	829	* join: inclusion inner join o outer join
	830	* group : campo para grupo en GROUP BY
	831	* having : condicion para el grupo
	832	* order : campo para criterio de ordenamiento ORDER BY
	833	* distinct: campos para hacer select distinct
	834	*/
	835	public function find($what = '') {
	836	$this->_connect();
	837	$what = get_params(func_get_args());
	838	$select = "SELECT ";
	839	if (isset($what['columns'])) {
	840	$select.= $what['columns'] ? ActiveRecord::sql_sanizite($what['columns']) : join(",", $this->fields);
	841	} elseif (isset($what['distinct'])) {
	842	$select.= 'DISTINCT ';
	843	$select.= $what['distinct'] ? ActiveRecord::sql_sanizite($what['distinct']) : join(",", $this->fields);
	844	} else {
	845	$select.= join(",", $this->fields);
	846	}
	847	if ($this->schema) {
	848	$select.= " FROM {$this->schema}.{$this->source}";
	849	} else {
	850	$select.= " FROM {$this->source}";
	851	}
	852	$select.= $this->convert_params_to_sql($what);
	853	$results = array();
	854	$all_results = $this->db->in_query($select);
	855	foreach($all_results AS $result) {
	856	$results[] = $this->dump_result($result);
	857	}
	858	$this->count = count($results);
	859	if (isset($what[0]) && is_numeric($what[0])) {
	860	if (!isset($results[0])) {
	861	$this->count = 0;
	862	return false;
	863	} else {
	864	$this->dump_result_self($all_results[0]);
	865	$this->count = 1;
	866	return $results[0];
	867	}
	868	} else {
	869	$this->count = count($results);
	870	return $results;
	871	}
	872	}
	873	/*
	874	* Arma una consulta SQL con el parametro $what, as�:
	875	* $what = get_params(func_get_args());
	876	* $select = "SELECT * FROM Clientes";
	877	* $select.= $this->convert_params_to_sql($what);
	878	*
	879	* @param string $what
	880	* @return string
	881	*/
	882	public function convert_params_to_sql($what = '') {
	883	$select = "";
	884	if (is_array($what)) {
	885	if (!isset($what['conditions'])) {
	886	if (!isset($this->primary_key[0]) && (isset($this->id) \|\| $this->is_view)) {
	887	$this->primary_key[0] = "id";
	888	}
	889	ActiveRecord::sql_item_sanizite($this->primary_key[0]);
	890	if (isset($what[0])) {
	891	if (is_numeric($what[0])) {
	892	$what['conditions'] = "{$this->primary_key[0]} = {$this->db->add_quotes($what[0]) }";
	893	} else {
	894	if ($what[0] == '') {
	895	$what['conditions'] = "{$this->primary_key[0]} = ''";
	896	} else {
	897	$what['conditions'] = $what[0];
	898	}
	899	}
	900	}
	901	}
	902	if (isset($what['join']) && $what['join']) {
	903	$select.= " {$what['join']}";
	904	}
	905	if (isset($what['conditions']) && $what['conditions']) {
	906	$select.= " WHERE {$what['conditions']}";
	907	}
	908	if (isset($what['group']) && $what['group']) {
	909	$select.= " GROUP BY {$what['group']}";
	910	}
	911	if (isset($what['having']) && $what['having']) {
	912	$select.= " HAVING {$what['having']}";
	913	}
	914	if (isset($what['order']) && $what['order']) {
	915	ActiveRecord::sql_sanizite($what['order']);
	916	$select.= " ORDER BY {$what['order']}";
	917	}
	918	$limit_args = array($select);
	919	if (isset($what['limit'])) {
	920	array_push($limit_args, "limit: $what[limit]");
	921	}
	922	if (isset($what['offset'])) {
	923	array_push($limit_args, "offset: $what[offset]");
	924	}
	925	if (count($limit_args) > 1) {
	926	$select = call_user_func_array(array($this, 'limit'), $limit_args);
	927	}
	928	} else {
	929	if (strlen($what)) {
	930	if (is_numeric($what)) {
	931	$select.= "WHERE {$this->primary_key[0]} = '$what'";
	932	} else {
	933	$select.= "WHERE $what";
	934	}
	935	}
	936	}
	937	return $select;
	938	}
	939	/*
	940	* Devuelve una clausula LIMIT adecuada al RDBMS empleado
	941	*
	942	* limit: maxima cantidad de elementos a mostrar
	943	* offset: desde que elemento se comienza a mostrar
	944	*
	945	* @param string $sql consulta select
	946	* @return String clausula LIMIT adecuada al RDBMS empleado
	947	*/
	948	public function limit($sql) {
	949	$args = func_get_args();
	950	return call_user_func_array(array($this->db, 'limit'), $args);
	951	}
	952	/**
	953	* Ejecuta un SELECT DISTINCT
	954	* @param string $what
	955	* @return array
	956	*
	957	* Soporta parametros iguales a find
	958	*
	959	*/
	960	public function distinct($what = '') {
	961	$this->_connect();
	962	$what = get_params(func_get_args());
	963	if ($this->schema) {
	964	$table = $this->schema . "." . $this->source;
	965	} else {
	966	$table = $this->source;
	967	}
	968	if (!isset($what['columns'])) {
	969	$what['columns'] = $what['0'];
	970	} else {
	971	if (!$what['columns']) {
	972	$what['columns'] = $what['0'];
	973	}
	974	}
	975	$what['columns'] = ActiveRecord::sql_sanizite($what['columns']);
	976	$select = "SELECT DISTINCT {$what['columns']} FROM $table ";
	977	/**
	978	* Se elimina el de indice cero ya que por defecto convert_params_to_sql lo considera como una condicion en WHERE
	979	*/
	980	unset($what[0]);
	981	$select.= $this->convert_params_to_sql($what);
	982	$results = array();
	983	foreach($this->db->fetch_all($select) as $result) {
	984	$results[] = $result[0];
	985	}
	986	return $results;
	987	}
	988	/**
	989	* Ejecuta una consulta en el RDBM directamente
	990	*
	991	* @param string $sql
	992	* @return resource
	993	*/
	994	public function select_one($sql) {
	995	$this->_connect();
	996	if (substr(ltrim($sql), 0, 7) != "SELECT") {
	997	$sql = "SELECT " . $sql;
	998	}
	999	$num = $this->db->fetch_one($sql);
	1000	return $num[0];
	1001	}
	1002	static public function static_select_one($sql) {
	1003	$db = db::raw_connect();
	1004	if (substr(ltrim($sql), 0, 7) != "SELECT") {
	1005	$sql = "SELECT " . $sql;
	1006	}
	1007	$num = $db->fetch_one($sql);
	1008	return $num[0];
	1009	}
	1010	/**
	1011	* Realiza un conteo de filas
	1012	*
	1013	* @param string $what
	1014	* @return integer
	1015	*/
	1016	public function count($what = '') {
	1017	$this->_connect();
	1018	$what = get_params(func_get_args());
	1019	if ($this->schema) {
	1020	$table = "{$this->schema}.{$this->source}";
	1021	} else {
	1022	$table = $this->source;
	1023	}
	1024	if (isset($what['distinct']) && $what['distinct']) {
	1025	if (isset($what['group']) \|\| isset($what['order'])) {
	1026	$select = "SELECT COUNT(*) FROM (SELECT DISTINCT {$what['distinct']} FROM $table ";
	1027	$select.= $this->convert_params_to_sql($what);
	1028	$select.= ') AS t ';
	1029	} else {
	1030	$select = "SELECT COUNT(DISTINCT {$what['distinct']}) FROM $table ";
	1031	$select.= $this->convert_params_to_sql($what);
	1032	}
	1033	} else {
	1034	$select = "SELECT COUNT(*) FROM $table ";
	1035	$select.= $this->convert_params_to_sql($what);
	1036	}
	1037	$num = $this->db->fetch_one($select);
	1038	return $num[0];
	1039	}
	1040	/**
	1041	* Realiza un promedio sobre el campo $what
	1042	*
	1043	* @param string $what
	1044	* @return array
	1045	*/
	1046	public function average($what = '') {
	1047	$this->_connect();
	1048	$what = get_params(func_get_args());
	1049	if (isset($what['column'])) {
	1050	if (!$what['column']) {
	1051	$what['column'] = $what[0];
	1052	}
	1053	} else {
	1054	$what['column'] = $what[0];
	1055	}
	1056	unset($what[0]);
	1057	ActiveRecord::sql_item_sanizite($what['column']);
	1058	if ($this->schema) {
	1059	$table = "{$this->schema}.{$this->source}";
	1060	} else {
	1061	$table = $this->source;
	1062	}
	1063	$select = "SELECT AVG({$what['column']}) FROM $table ";
	1064	$select.= $this->convert_params_to_sql($what);
	1065	$num = $this->db->fetch_one($select);
	1066	return $num[0];
	1067	}
	1068	public function sum($what = '') {
	1069	$this->_connect();
	1070	$what = get_params(func_get_args());
	1071	if (isset($what['column'])) {
	1072	if (!$what['column']) {
	1073	$what['column'] = $what[0];
	1074	}
	1075	} else {
	1076	$what['column'] = $what[0];
	1077	}
	1078	unset($what[0]);
	1079	ActiveRecord::sql_item_sanizite($what['column']);
	1080	if ($this->schema) {
	1081	$table = "{$this->schema}.{$this->source}";
	1082	} else {
	1083	$table = $this->source;
	1084	}
	1085	$select = "SELECT SUM({$what['column']}) FROM $table ";
	1086	$select.= $this->convert_params_to_sql($what);
	1087	$num = $this->db->fetch_one($select);
	1088	return $num[0];
	1089	}
	1090	/**
	1091	* Busca el valor maximo para el campo $what
	1092	*
	1093	* @param string $what
	1094	* @return mixed
	1095	*/
	1096	public function maximum($what = '') {
	1097	$this->_connect();
	1098	$what = get_params(func_get_args());
	1099	if (isset($what['column'])) {
	1100	if (!$what['column']) {
	1101	$what['column'] = $what[0];
	1102	}
	1103	} else {
	1104	$what['column'] = $what[0];
	1105	}
	1106	unset($what[0]);
	1107	ActiveRecord::sql_item_sanizite($what['column']);
	1108	if ($this->schema) {
	1109	$table = "{$this->schema}.{$this->source}";
	1110	} else {
	1111	$table = $this->source;
	1112	}
	1113	$select = "SELECT MAX({$what['column']}) FROM $table ";
	1114	$select.= $this->convert_params_to_sql($what);
	1115	$num = $this->db->fetch_one($select);
	1116	return $num[0];
	1117	}
	1118	/**
	1119	* Busca el valor minimo para el campo $what
	1120	*
	1121	* @param string $what
	1122	* @return mixed
	1123	*/
	1124	public function minimum($what = '') {
	1125	$this->_connect();
	1126	$what = get_params(func_get_args());
	1127	if (isset($what['column'])) {
	1128	if (!$what['column']) {
	1129	$what['column'] = $what[0];
	1130	}
	1131	} else {
	1132	$what['column'] = $what[0];
	1133	}
	1134	unset($what[0]);
	1135	ActiveRecord::sql_item_sanizite($what['column']);
	1136	if ($this->schema) {
	1137	$table = "{$this->schema}.{$this->source}";
	1138	} else {
	1139	$table = $this->source;
	1140	}
	1141	$select = "SELECT MIN({$what['column']}) FROM $table ";
	1142	$select.= $this->convert_params_to_sql($what);
	1143	$num = $this->db->fetch_one($select);
	1144	return $num[0];
	1145	}
	1146	/**
	1147	* Realiza un conteo directo mediante $sql
	1148	*
	1149	* @param string $sqlQuery
	1150	* @return mixed
	1151	*/
	1152	public function count_by_sql($sqlQuery) {
	1153	$this->_connect();
	1154	$num = $this->db->fetch_one($sqlQuery);
	1155	return $num[0];
	1156	}
	1157	/**
	1158	* Iguala los valores de un resultado de la base de datos
	1159	* en un nuevo objeto con sus correspondientes
	1160	* atributos de la clase
	1161	*
	1162	* @param array $result
	1163	* @return ActiveRecord
	1164	*/
	1165	function dump_result($result) {
	1166	$this->_connect();
	1167	$obj = clone $this;
	1168	/**
	1169	* Consulta si la clase es padre de otra y crea el tipo de dato correcto
	1170	*/
	1171	if (isset($result['type'])) {
	1172	if (in_array($result['type'], $this->parent_of)) {
	1173	if (class_exists($result['type'])) {
	1174	$obj = new $result['type'];
	1175	unset($result['type']);
	1176	}
	1177	}
	1178	}
	1179	$this->_dump_lock = true;
	1180	if (is_array($result)) {
	1181	foreach($result as $k => $r) {
	1182	if (!is_numeric($k)) {
	1183	$obj->$k = stripslashes($r);
	1184	}
	1185	}
	1186	}
	1187	$this->_dump_lock = false;
	1188	return $obj;
	1189	}
	1190	/**
	1191	* Iguala los valores de un resultado de la base de datos
	1192	* con sus correspondientes atributos de la clase
	1193	*
	1194	* @param array $result
	1195	* @return ActiveRecord
	1196	*/
	1197	public function dump_result_self($result) {
	1198	$this->_connect();
	1199	$this->_dump_lock = true;
	1200	if (is_array($result)) {
	1201	foreach($result as $k => $r) {
	1202	if (!is_numeric($k)) {
	1203	$this->$k = stripslashes($r);
	1204	}
	1205	}
	1206	}
	1207	$this->_dump_lock = false;
	1208	}
	1209	/**
	1210	* Create a new Row using values from $_REQUEST
	1211	*
	1212	* @param string $form form name for request, equivalent to $_REQUEST[$form]
	1213	* @return boolean success
	1214	*/
	1215	public function create_from_request($form = '') {
	1216	if ($form) {
	1217	return $this->create($_REQUEST[$form]);
	1218	} else {
	1219	return $this->create($_REQUEST);
	1220	}
	1221	}
	1222	/**
	1223	* Saves a new Row using values from $_REQUEST
	1224	*
	1225	* @param string $form form name for request, equivalent to $_REQUEST[$form]
	1226	* @return boolean success
	1227	*/
	1228	public function save_from_request($form = '') {
	1229	if ($form) {
	1230	return $this->save($_REQUEST[$form]);
	1231	} else {
	1232	return $this->save($_REQUEST);
	1233	}
	1234	}
	1235	/**
	1236	* Updates a Row using values from $_REQUEST
	1237	*
	1238	* @param string $form form name for request, equivalent to $_REQUEST[$form]
	1239	* @return boolean success
	1240	*/
	1241	public function update_from_request($form = '') {
	1242	if ($form) {
	1243	return $this->update($_REQUEST[$form]);
	1244	} else {
	1245	return $this->update($_REQUEST);
	1246	}
	1247	}
	1248	/**
	1249	* Creates a new Row in map table
	1250	*
	1251	* @param mixed $values
	1252	* @return success boolean
	1253	*/
	1254	public function create() {
	1255	$this->_connect();
	1256	if (func_num_args() > 0) {
	1257	$params = get_params(func_get_args());
	1258	$values = (isset($params[0]) && is_array($params[0])) ? $params[0] : $params;
	1259	foreach($this->fields as $field) {
	1260	if (isset($values[$field])) {
	1261	$this->$field = $values[$field];
	1262	}
	1263	}
	1264	}
	1265	if ($this->primary_key[0] == 'id') {
	1266	$this->id = null;
	1267	}
	1268	return $this->save();
	1269	}
	1270	/**
	1271	* Consulta si un determinado registro existe o no
	1272	* en la entidad de la base de datos
	1273	*
	1274	* @return boolean
	1275	*/
	1276	function exists($where_pk = '') {
	1277	$this->_connect();
	1278	if ($this->schema) {
	1279	$table = "{$this->schema}.{$this->source}";
	1280	} else {
	1281	$table = $this->source;
	1282	}
	1283	if (!$where_pk) {
	1284	$where_pk = array();
	1285	foreach($this->primary_key as $key) {
	1286	if ($this->$key) {
	1287	$where_pk[] = " $key = '{$this->$key}'";
	1288	}
	1289	}
	1290	if (count($where_pk)) {
	1291	$this->_where_pk = join(" AND ", $where_pk);
	1292	} else {
	1293	return 0;
	1294	}
	1295	$query = "SELECT COUNT(*) FROM $table WHERE {$this->_where_pk}";
	1296	} else {
	1297	if (is_numeric($where_pk)) {
	1298	$query = "SELECT(*) FROM $table WHERE id = '$where_pk'";
	1299	} else {
	1300	$query = "SELECT COUNT(*) FROM $table WHERE $where_pk";
	1301	}
	1302	}
	1303	$num = $this->db->fetch_one($query);
	1304	return $num[0];
	1305	}
	1306	/**
	1307	* Saves Information on the ActiveRecord Properties
	1308	* @param array $values array de valores a cargar
	1309	* @return boolean success
	1310	*/
	1311	public function save() {
	1312	$this->_connect();
	1313	if (func_num_args() > 0) {
	1314	$params = get_params(func_get_args());
	1315	$values = (isset($params[0]) && is_array($params[0])) ? $params[0] : $params;
	1316	foreach($this->fields as $field) {
	1317	if (isset($values[$field])) {
	1318	$this->$field = $values[$field];
	1319	}
	1320	}
	1321	}
	1322	$ex = $this->exists();
	1323	if ($this->schema) {
	1324	$table = $this->schema . "." . $this->source;
	1325	} else {
	1326	$table = $this->source;
	1327	}
	1328	#Run Validation Callbacks Before
	1329	if (method_exists($this, 'before_validation')) {
	1330	if ($this->before_validation() == 'cancel') {
	1331	return false;
	1332	}
	1333	} else {
	1334	if (isset($this->before_validation)) {
	1335	$method = $this->before_validation;
	1336	if ($this->$method() == 'cancel') {
	1337	return false;
	1338	}
	1339	}
	1340	}
	1341	if (!$ex && method_exists($this, "before_validation_on_create")) {
	1342	if ($this->before_validation_on_create() == 'cancel') {
	1343	return false;
	1344	}
	1345	} else {
	1346	if (isset($this->before_validation_on_create)) {
	1347	$method = $this->before_validation_on_create;
	1348	if ($this->$method() == 'cancel') {
	1349	return false;
	1350	}
	1351	}
	1352	}
	1353	if ($ex && method_exists($this, "before_validation_on_update")) {
	1354	if ($this->before_validation_on_update() == 'cancel') {
	1355	return false;
	1356	}
	1357	} else {
	1358	if (isset($this->before_validation_on_update)) {
	1359	$method = $this->before_validation_on_update;
	1360	if ($this->$method() == 'cancel') {
	1361	return false;
	1362	}
	1363	}
	1364	}
	1365	/**
	1366	* Recordamos que aqui no aparecen los que tienen valores por defecto,
	1367	* pero sin embargo se debe estar pendiente de validar en las otras verificaciones
	1368	* los campos nulos, ya que en estas si el campo es nulo, realmente se refiere a un campo que
	1369	* debe tomar el valor por defecto
	1370	*
	1371	*/
	1372	$e = false;
	1373	for ($i = 0;$i <= count($this->not_null) - 1;$i++) {
	1374	$f = $this->not_null[$i];
	1375	if (isset($this->$f) && (is_null($this->$f) \|\| $this->$f == '')) {
	1376	if (!$ex && $f == 'id') {
	1377	continue;
	1378	}
	1379	if (!$ex && in_array($f, $this->_at)) {
	1380	continue;
	1381	}
	1382	if ($ex && in_array($f, $this->_in)) {
	1383	continue;
	1384	}
	1385	Flash::error("Error: El campo $f no puede ser nulo");
	1386	$e = true;
	1387	}
	1388	}
	1389	if ($e) {
	1390	return false;
	1391	}
	1392	/**
	1393	* Validacion validates_presence
	1394	*
	1395	*/
	1396	$e = false;
	1397	foreach($this->_validates_presence as $f => $opt) {
	1398	$f = $this->not_null[$i];
	1399	if (isset($this->$f) && (is_null($this->$f) \|\| $this->$f == '')) {
	1400	if (!$ex && $f == 'id') {
	1401	continue;
	1402	}
	1403	if (!$ex && in_array($f, $this->_at)) {
	1404	continue;
	1405	}
	1406	if ($ex && in_array($f, $this->_in)) {
	1407	continue;
	1408	}
	1409	if (isset($opt['message'])) {
	1410	Flash::error($opt['message']);
	1411	} else {
	1412	$field = isset($opt['field']) ? $opt['field'] : $f;
	1413	Flash::error("Error: El campo $field no puede ser nulo");
	1414	}
	1415	$e = true;
	1416	}
	1417	}
	1418	if ($e) {
	1419	return false;
	1420	}
	1421	/**
	1422	* Validacion validates_length
	1423	*
	1424	*/
	1425	$e = false;
	1426	foreach($this->_validates_length as $f => $opt) {
	1427	if (isset($this->$f) && !is_null($this->$f) && $this->$f != '') {
	1428	$field = isset($opt['field']) ? $opt['field'] : $f;
	1429	if (isset($opt['in'])) {
	1430	$in = explode(":", $opt['in']);
	1431	if (is_numeric($in[0]) && is_numeric($in[1])) {
	1432	$opt['minimum'] = $in[0];
	1433	$opt['maximum'] = $in[1];
	1434	}
	1435	}
	1436	if (isset($opt['minimum']) && is_numeric($opt['minimum'])) {
	1437	$n = $opt['minimum'];
	1438	if (strlen($this->$f) < $n) {
	1439	if (!isset($opt['too_short'])) {
	1440	Flash::error("Error: El campo $field debe tener como mínimo $n caracteres");
	1441	$e = true;
	1442	} else {
	1443	Flash::error($opt['too_short']);
	1444	$e = true;
	1445	}
	1446	}
	1447	}
	1448	if (isset($opt['maximum']) && is_numeric($opt['maximum'])) {
	1449	$n = $opt['maximum'];
	1450	if (strlen($this->$f) > $n) {
	1451	if (!isset($opt['too_long'])) {
	1452	Flash::error("Error: El campo $field debe tener como máximo $n caracteres");
	1453	$e = true;
	1454	} else {
	1455	Flash::error($opt['too_long']);
	1456	$e = true;
	1457	}
	1458	}
	1459	}
	1460	}
	1461	}
	1462	if ($e) {
	1463	return false;
	1464	}
	1465	/**
	1466	* Validacion validates_inclusion
	1467	*
	1468	*/
	1469	$e = false;
	1470	foreach($this->_validates_inclusion as $finc => $list) {
	1471	if (isset($this->$finc) && !is_null($this->$finc) && $this->$finc != '') {
	1472	if (!is_array($list[1]) && $this->$finc != $list[1]) {
	1473	if (isset($list['message'])) {
	1474	Flash::error($list['message']);
	1475	} else {
	1476	$field = isset($list['field']) ? $list['field'] : ucwords($finc);
	1477	Flash::error("$field debe tener un valor entre ({$list[1]})");
	1478	}
	1479	$e = true;
	1480	} else {
	1481	if (!in_array($this->$finc, $list[1])) {
	1482	if (isset($list['message'])) {
	1483	Flash::error($list['message']);
	1484	} else {
	1485	$field = isset($list['field']) ? $list['field'] : ucwords($finc);
	1486	Flash::error("$field debe tener un valor entre (" . join(",", $list[1]) . ")");
	1487	}
	1488	$e = true;
	1489	}
	1490	}
	1491	}
	1492	}
	1493	if ($e) {
	1494	return false;
	1495	}
	1496	/**
	1497	* Validacion validates_exclusion
	1498	*
	1499	*/
	1500	$e = false;
	1501	foreach($this->_validates_exclusion as $finc => $list) {
	1502	if (isset($this->$finc) && !is_null($this->$finc) && $this->$finc != '') {
	1503	if (!is_array($list[1]) && $this->$finc == $list[1]) {
	1504	if (isset($list['message'])) {
	1505	Flash::error($list['message']);
	1506	} else {
	1507	$field = isset($list['field']) ? $list['field'] : ucwords($finc);
	1508	Flash::error("$field no debe tener un valor entre ({$list[1]})");
	1509	}
	1510	$e = true;
	1511	} else {
	1512	if (in_array($this->$finc, $list[1])) {
	1513	if (isset($list['message'])) {
	1514	Flash::error($list['message']);
	1515	} else {
	1516	$field = isset($list['field']) ? $list['field'] : ucwords($finc);
	1517	Flash::error("$field no debe tener un valor entre (" . join(",", $list[1]) . ")");
	1518	}
	1519	$e = true;
	1520	}
	1521	}
	1522	}
	1523	}
	1524	if ($e) {
	1525	return false;
	1526	}
	1527	/**
	1528	* Validacion validates_numericality
	1529	*
	1530	*/
	1531	$e = false;
	1532	foreach($this->_validates_numericality as $fnum => $opt) {
	1533	if (isset($this->$fnum) && !is_null($this->$fnum) && $this->$fnum != '') {
	1534	if (!is_numeric($this->$fnum)) {
	1535	if (isset($opt['message'])) {
	1536	Flash::error($opt['message']);
	1537	} else {
	1538	$field = isset($opt['field']) ? $opt['field'] : ucwords($fnum);
	1539	Flash::error("$field debe tener un valor numérico");
	1540	}
	1541	$e = true;
	1542	}
	1543	}
	1544	}
	1545	if ($e) {
	1546	return false;
	1547	}
	1548	/**
	1549	* Validacion validates_format
	1550	*
	1551	*/
	1552	$e = false;
	1553	foreach($this->_validates_format as $fkey => $opt) {
	1554	if (isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey != '') {
	1555	if (!ereg($opt[1], $this->$fkey)) {
	1556	if (isset($opt['message'])) {
	1557	Flash::error($opt['message']);
	1558	} else {
	1559	$field = isset($opt['field']) ? $opt['field'] : $fkey;
	1560	Flash::error("Formato erroneo para $field");
	1561	}
	1562	$e = true;
	1563	}
	1564	}
	1565	}
	1566	if ($e) {
	1567	return false;
	1568	}
	1569	/**
	1570	* Validacion validates_date
	1571	*
	1572	*/
	1573	$e = false;
	1574	foreach($this->_validates_date as $fkey => $opt) {
	1575	if (isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey != '') {
	1576	if (!ereg("^[0-9]{4}[-/](0[1-9]\|1[12])[-/](0[1-9]\|[12][0-9]\|3[01])$", $this->$fkey, $regs)) {
	1577	if (isset($opt['message'])) {
	1578	Flash::error($opt['message']);
	1579	} else {
	1580	$field = isset($opt['field']) ? $opt['field'] : $fkey;
	1581	Flash::error("Formato de fecha ({$this->$fkey}) erroneo para $field");
	1582	}
	1583	$e = true;
	1584	}
	1585	}
	1586	}
	1587	if ($e) {
	1588	return false;
	1589	}
	1590	/**
	1591	* Validacion validates_email
	1592	*
	1593	*/
	1594	$e = false;
	1595	foreach($this->_validates_email as $fkey) {
	1596	if (isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey != '') {
	1597	if (!ereg("^[a-zA-Z0-9_\.\+]+@[a-zA-Z0-9_]+(\.[a-zA-Z0-9_]+)*$", $this->$fkey, $regs)) {
	1598	if (isset($opt['message'])) {
	1599	Flash::error($opt['message']);
	1600	} else {
	1601	$field = isset($opt['field']) ? $opt['field'] : $fkey;
	1602	Flash::error("Formato de e-mail erroneo en el campo $field");
	1603	}
	1604	$e = true;
	1605	}
	1606	}
	1607	}
	1608	if ($e) {
	1609	return false;
	1610	}
	1611	/**
	1612	* Validacion validates_uniqueness
	1613	*
	1614	*/
	1615	$e = false;
	1616	foreach($this->_validates_uniqueness as $fkey => $opt) {
	1617	ActiveRecord::sql_item_sanizite($fkey);
	1618	if (isset($this->$fkey) && !is_null($this->$fkey) && $this->$fkey != '') {
	1619	if ($ex) {
	1620	$copy = clone $this;
	1621	$copy->find_first("$fkey = {$this->db->add_quotes($this->$fkey) }");
	1622	$number = $this->db->fetch_one("SELECT COUNT(*) FROM $table WHERE $fkey = {$this->db->add_quotes($this->$fkey) } and $fkey <> {$this->db->add_quotes($copy->$fkey) }");
	1623	} else {
	1624	$number = $this->db->fetch_one("SELECT COUNT(*) FROM $table WHERE $fkey = {$this->db->add_quotes($this->$fkey) }");
	1625	}
	1626	if ((int)$number[0]) {
	1627	if (isset($opt['message'])) {
	1628	Flash::error($opt['message']);
	1629	} else {
	1630	$field = isset($opt['field']) ? $opt['field'] : $fkey;
	1631	Flash::error("El valor '{$this->$fkey}' ya existe para el campo $field");
	1632	}
	1633	$e = true;
	1634	}
	1635	}
	1636	}
	1637	if ($e) {
	1638	return false;
	1639	}
	1640	#Run Validation Callbacks After
	1641	if (!$ex && method_exists($this, "after_validation_on_create")) {
	1642	if ($this->after_validation_on_create() == 'cancel') {
	1643	return false;
	1644	}
	1645	} else {
	1646	if (isset($this->after_validation_on_create)) {
	1647	$method = $this->after_validation_on_create;
	1648	if ($this->$method() == 'cancel') {
	1649	return false;
	1650	}
	1651	}
	1652	}
	1653	if ($ex && method_exists($this, "after_validation_on_update")) {
	1654	if ($this->after_validation_on_update() == 'cancel') {
	1655	return false;
	1656	}
	1657	} else {
	1658	if (isset($this->after_validation_on_update)) {
	1659	$method = $this->after_validation_on_update;
	1660	if ($this->$method() == 'cancel') return false;
	1661	}
	1662	}
	1663	if (method_exists($this, 'after_validation')) {
	1664	if ($this->after_validation() == 'cancel') {
	1665	return false;
	1666	}
	1667	} else {
	1668	if (isset($this->after_validation)) {
	1669	$method = $this->after_validation;
	1670	if ($this->$method() == 'cancel') {
	1671	return false;
	1672	}
	1673	}
	1674	}
	1675	# Run Before Callbacks
	1676	if (method_exists($this, "before_save")) {
	1677	if ($this->before_save() == 'cancel') {
	1678	return false;
	1679	}
	1680	} else {
	1681	if (isset($this->before_save)) {
	1682	$method = $this->before_save;
	1683	if ($this->$method() == 'cancel') {
	1684	return false;
	1685	}
	1686	}
	1687	}
	1688	if ($ex && method_exists($this, "before_update")) {
	1689	if ($this->before_update() == 'cancel') {
	1690	return false;
	1691	}
	1692	} else {
	1693	if (isset($this->before_update)) {
	1694	$method = $this->before_update;
	1695	if ($this->$method() == 'cancel') {
	1696	return false;
	1697	}
	1698	}
	1699	}
	1700	if (!$ex && method_exists($this, "before_create")) {
	1701	if ($this->before_create() == 'cancel') {
	1702	return false;
	1703	}
	1704	} else {
	1705	if (isset($this->before_create)) {
	1706	$method = $this->before_create;
	1707	if ($this->$method() == 'cancel') {
	1708	return false;
	1709	}
	1710	}
	1711	}
	1712	$environment = Config::read("environment.ini");
	1713	$config = $environment->{$this->get_mode() };
	1714	if ($ex) {
	1715	$fields = array();
	1716	$values = array();
	1717	foreach($this->non_primary as $np) {
	1718	$np = ActiveRecord::sql_item_sanizite($np);
	1719	if (in_array($np, $this->_in)) {
	1720	if ($config->database->type == 'oracle') {
	1721	$this->$np = date("Y-m-d");
	1722	} else {
	1723	$this->$np = date("Y-m-d G:i:s");
	1724	}
	1725	}
	1726	if (isset($this->$np)) {
	1727	$fields[] = $np;
	1728	if (is_null($this->$np) \|\| $this->$np == '') {
	1729	$values[] = "NULL";
	1730	} elseif (substr($this->$np, 0, 1) == "%") {
	1731	$values[] = str_replace("%", "", $this->$np);
	1732	} else {
	1733	/**
	1734	* Se debe especificar el formato de fecha en Oracle
	1735	*/
	1736	if ($this->_data_type[$np] == 'date' && $config->database->type == 'oracle') {
	1737	$values[] = "TO_DATE(" . $this->db->add_quotes($this->$np) . ", 'YYYY-MM-DD')";
	1738	} else {
	1739	$values[] = $this->db->add_quotes($this->$np);
	1740	}
	1741	}
	1742	}
	1743	}
	1744	$val = $this->db->update($table, $fields, $values, $this->_where_pk);
	1745	} else {
	1746	$fields = array();
	1747	$values = array();
	1748	foreach($this->fields as $field) {
	1749	if ($field != 'id' && !$this->id) {
	1750	if (in_array($field, $this->_at)) {
	1751	if ($config->database->type == 'oracle') {
	1752	$this->$field = date("Y-m-d");
	1753	} else {
	1754	$this->$field = date("Y-m-d G:i:s");
	1755	}
	1756	}
	1757	if (in_array($field, $this->_in)) {
	1758	unset($this->$field);
	1759	}
	1760	$use_default = in_array($field, $this->_with_default) && isset($this->$field) && (is_null($this->$field) \|\| $this->$field == '');
	1761	if (isset($this->$field) && !$use_default) {
	1762	$fields[] = ActiveRecord::sql_sanizite($field);
	1763	if (substr($this->$field, 0, 1) == "%") {
	1764	$values[] = str_replace("%", "", $this->$field);
	1765	} else {
	1766	if ($this->is_a_numeric_type($field) \|\| $this->$field == null) {
	1767	$values[] = addslashes($this->$field !== '' && $this->$field !== null ? $this->$field : "NULL");
	1768	} else {
	1769	if ($this->_data_type[$field] == 'date' && $config->database->type == 'oracle') {
	1770	/**
	1771	* Se debe especificar el formato de fecha en Oracle
	1772	*/
	1773	$values[] = "TO_DATE(" . $this->db->add_quotes($this->$field) . ", 'YYYY-MM-DD')";
	1774	} else {
	1775	if (!is_null($this->$field) && $this->$field != '') {
	1776	$values[] = $this->db->add_quotes($this->$field);
	1777	} else {
	1778	$values[] = "NULL";
	1779	}
	1780	}
	1781	}
	1782	}
	1783	}
	1784	} else {
	1785	/**
	1786	* Campos autonumericos en Oracle deben utilizar una sequencia auxiliar
	1787	*/
	1788	if ($config->database->type == 'oracle') {
	1789	if (!$this->id) {
	1790	$fields[] = "id";
	1791	$values[] = $this->source . "_id_seq.NEXTVAL";
	1792	}
	1793	}
	1794	if ($config->database->type == 'informix') {
	1795	if (!$this->id) {
	1796	$fields[] = "id";
	1797	$values[] = 0;
	1798	}
	1799	}
	1800	}
	1801	}
	1802	$val = $this->db->insert($table, $values, $fields);
	1803	}
	1804	if (!isset($config->database->pdo) && $config->database->type == 'oracle') {
	1805	$this->commit();
	1806	}
	1807	if (!$ex) {
	1808	$this->db->logger = true;
	1809	$m = $this->db->last_insert_id($table, $this->primary_key[0]);
	1810	$this->find_first($m);
	1811	}
	1812	if ($val) {
	1813	if ($ex && method_exists($this, "after_update")) {
	1814	if ($this->after_update() == 'cancel') {
	1815	return false;
	1816	}
	1817	} else {
	1818	if (isset($this->after_update)) {
	1819	$method = $this->after_update;
	1820	if ($this->$method() == 'cancel') {
	1821	return false;
	1822	}
	1823	}
	1824	}
	1825	if (!$ex && method_exists($this, "after_create")) {
	1826	if ($this->after_create() == 'cancel') {
	1827	return false;
	1828	}
	1829	} else {
	1830	if (isset($this->after_create)) {
	1831	$method = $this->after_create;
	1832	if ($this->$method() == 'cancel') {
	1833	return false;
	1834	}
	1835	}
	1836	}
	1837	if (method_exists($this, "after_save")) {
	1838	if ($this->after_save() == 'cancel') {
	1839	return false;
	1840	}
	1841	} else {
	1842	if (isset($this->after_save)) {
	1843	$method = $this->after_save;
	1844	if ($this->$method() == 'cancel') {
	1845	return false;
	1846	}
	1847	}
	1848	}
	1849	return $val;
	1850	} else {
	1851	return false;
	1852	}
	1853	}
	1854	/**
	1855	* Find All data in the Relational Table
	1856	*
	1857	* @param string $field
	1858	* @param string $value
	1859	* @return ActiveRecod Cursor
	1860	*/
	1861	function find_all_by($field, $value) {
	1862	ActiveRecord::sql_item_sanizite($field);
	1863	return $this->find("conditions: $field = {$this->db->add_quotes($value) }");
	1864	}
	1865	/**
	1866	* Updates Data in the Relational Table
	1867	*
	1868	* @param mixed $values
	1869	* @return boolean sucess
	1870	*/
	1871	function update() {
	1872	$this->_connect();
	1873	if (func_num_args() > 0) {
	1874	$params = get_params(func_get_args());
	1875	$values = (isset($params[0]) && is_array($params[0])) ? $params[0] : $params;
	1876	foreach($this->fields as $field) {
	1877	if (isset($values[$field])) {
	1878	$this->$field = $values[$field];
	1879	}
	1880	}
	1881	}
	1882	if ($this->exists()) {
	1883	return $this->save();
	1884	} else {
	1885	Flash::error('No se puede actualizar porque el registro no existe');
	1886	return false;
	1887	}
	1888	}
	1889	/**
	1890	* Deletes data from Relational Map Table
	1891	*
	1892	* @param mixed $what
	1893	*/
	1894	function delete($what = '') {
	1895	$this->_connect();
	1896	if (func_num_args() > 1) {
	1897	$what = get_params(func_get_args());
	1898	}
	1899	if ($this->schema) {
	1900	$table = $this->schema . "." . $this->source;
	1901	} else {
	1902	$table = $this->source;
	1903	}
	1904	$conditions = "";
	1905	if (is_array($what)) {
	1906	if ($what["conditions"]) {
	1907	$conditions = $what["conditions"];
	1908	}
	1909	} else {
	1910	if (is_numeric($what)) {
	1911	ActiveRecord::sql_sanizite($this->primary_key[0]);
	1912	$conditions = "{$this->primary_key[0]} = '$what'";
	1913	} else {
	1914	if ($what) {
	1915	$conditions = $what;
	1916	} else {
	1917	ActiveRecord::sql_sanizite($this->primary_key[0]);
	1918	$conditions = "{$this->primary_key[0]} = '{$this->{$this->primary_key[0]}}'";
	1919	}
	1920	}
	1921	}
	1922	if (method_exists($this, "before_delete")) {
	1923	if ($this->id) {
	1924	$this->find($this->id);
	1925	}
	1926	if ($this->before_delete() == 'cancel') {
	1927	return false;
	1928	}
	1929	} else {
	1930	if (isset($this->before_delete)) {
	1931	if ($this->id) {
	1932	$this->find($this->id);
	1933	}
	1934	$method = $this->before_delete;
	1935	if ($this->$method() == 'cancel') {
	1936	return false;
	1937	}
	1938	}
	1939	}
	1940	$val = $this->db->delete($table, $conditions);
	1941	if ($val) {
	1942	if (method_exists($this, "after_delete")) {
	1943	if ($this->after_delete() == 'cancel') {
	1944	return false;
	1945	}
	1946	} else {
	1947	if (isset($this->after_delete)) {
	1948	$method = $this->after_delete;
	1949	if ($this->$method() == 'cancel') {
	1950	return false;
	1951	}
	1952	}
	1953	}
	1954	}
	1955	return $val;
	1956	}
	1957	/**
	1958	* Actualiza todos los atributos de la entidad
	1959	* $Clientes->update_all("estado='A', fecha='2005-02-02'", "id>100");
	1960	* $Clientes->update_all("estado='A', fecha='2005-02-02'", "id>100", "limit: 10");
	1961	*
	1962	* @param string $values
	1963	*/
	1964	function update_all($values) {
	1965	$this->_connect();
	1966	$params = array();
	1967	if ($this->schema) {
	1968	$table = $this->schema . "." . $this->source;
	1969	} else {
	1970	$table = $this->source;
	1971	}
	1972	if (func_num_args() > 1) {
	1973	$params = get_params(func_get_args());
	1974	}
	1975	if (!isset($params['conditions']) \|\| !$params['conditions']) {
	1976	if (isset($params[1])) {
	1977	$params['conditions'] = $params[1];
	1978	} else {
	1979	$params['conditions'] = "";
	1980	}
	1981	}
	1982	if ($params['conditions']) {
	1983	$params['conditions'] = " WHERE " . $params['conditions'];
	1984	}
	1985	$sql = "UPDATE $table SET $values {$params['conditions']}";
	1986	$limit_args = array($sql);
	1987	if (isset($params['limit'])) {
	1988	array_push($limit_args, "limit: $params[limit]");
	1989	}
	1990	if (isset($params['offset'])) {
	1991	array_push($limit_args, "offset: $params[offset]");
	1992	}
	1993	if (count($limit_args) > 1) {
	1994	$sql = call_user_func_array(array($this, 'limit'), $limit_args);
	1995	}
	1996	$environment = Config::read("environment.ini");
	1997	$config = $environment->{$this->get_mode() };
	1998	if (!isset($config->database->pdo) \|\| !$config->database->pdo) {
	1999	if ($config->database->type == "informix") {
	2000	$this->db->set_return_rows(false);
	2001	}
	2002	}
	2003	return $this->db->query($sql);
	2004	}
	2005	/**
	2006	* Delete All data from Relational Map Table
	2007	*
	2008	* @param string $conditions
	2009	* @return boolean
	2010	*/
	2011	function delete_all($conditions = '') {
	2012	$this->_connect();
	2013	$limit = "";
	2014	if ($this->schema) {
	2015	$table = $this->schema . "." . $this->source;
	2016	} else {
	2017	$table = $this->source;
	2018	}
	2019	if (func_num_args() > 1) {
	2020	$params = get_params(func_get_args());
	2021	$limit_args = array($select);
	2022	if (isset($params['limit'])) {
	2023	array_push($limit_args, "limit: $params[limit]");
	2024	}
	2025	if (isset($params['offset'])) {
	2026	array_push($limit_args, "offset: $params[offset]");
	2027	}
	2028	if (count($limit_args) > 1) {
	2029	$select = call_user_func_array(array($this, 'limit'), $limit_args);
	2030	}
	2031	}
	2032	return $this->db->delete($table, $conditions);
	2033	}
	2034	/**
	2035	* *********************************************************************************
	2036	* Metodos de Debug
	2037	* *********************************************************************************
	2038	*/
	2039	/**
	2040	* Imprime una version humana de los valores de los campos
	2041	* del modelo en una sola linea
	2042	*
	2043	*/
	2044	public function inspect() {
	2045	$this->_connect();
	2046	$inspect = array();
	2047	foreach($this->fields as $field) {
	2048	if (!is_array($field)) {
	2049	$inspect[] = "$field: {$this->$field}";
	2050	}
	2051	}
	2052	return join(", ", $inspect);
	2053	}
	2054	/**
	2055	* *********************************************************************************
	2056	* Metodos de Validacion
	2057	* *********************************************************************************
	2058	*/
	2059	/**
	2060	* Validate that Attributes cannot have a NULL value
	2061	*/
	2062	protected function validates_presence_of() {
	2063	$this->_connect();
	2064	$params = get_params(func_get_args());
	2065	if (is_array($params[0])) {
	2066	$params = $params[0];
	2067	}
	2068	$fields = array();
	2069	for ($i = 0;isset($params[$i]);$i++) {
	2070	$fields[] = $params[$i];
	2071	unset($params[$i]);
	2072	$i++;
	2073	}
	2074	foreach($fields as $p) {
	2075	if (!in_array($p, $this->fields) && !isset($this->$p)) {
	2076	throw new ActiveRecordException('No se puede validar presencia de "' . $p . '"
	2077	en el modelo ' . $this->source . ' porque no existe el atributo</u><br>
2230	2078	Verifique que el atributo este bien escrito y/o exista en la relación ');
2231		return false;
2232		}
2233		if(!isset($this->_validates_presence[$p])){
2234		$this->_validates_presence[$p] = $params;
2235		}
2236		}
2237		return true;
2238		}
2239
2240		/**
2241		* Valida el tamaño de ciertos campos antes de insertar
2242		* o actualizar
2243		*
2244		* @params string $field campo a validar
2245		*
2246		* $this->validates_length_of("nombre", "minumum: 15")
2247		* $this->validates_length_of("nombre", "minumum: 15", "too_short: El Nombre es muy corto")
2248		* $this->validates_length_of("nombre", "maximum: 40", "too_long: El nombre es muy largo")
2249		* $this->validates_length_of("nombre", "in: 15:40",
2250		* "too_short: El Nombre es muy corto",
2251		* "too_long: El nombre es muy largo (40 min)"
2252		* )
2253		*
2254		* @return boolean
2255		*/
2256		protected function validates_length_of($field){
2257		$this->_connect();
2258		$params = get_params(func_get_args());
2259		if(!isset($this->_validates_length[$field])) {
2260		$this->_validates_length[$field] =$params;
2261		}
2262		return true;
2263		}
2264
2265		/**
2266		* Valida que el campo se encuentre entre los valores de una lista
2267		* antes de insertar o actualizar
2268		*
2269		* $this->_validates_inclusion_in("estado", array("A", "I"))
2270		*
2271		* @param string $campo
2272		* @param array $list
2273		* @return boolean
2274		*/
2275		protected function validates_inclusion_in($campo, $list){
2276		$this->_connect();
2277		if(!isset($this->_validates_inclusion[$campo])) {
2278		$this->_validates_inclusion[$campo] = get_params(func_get_args());
2279		}
2280		return true;
2281		}
2282
2283		/**
2284		* Valida que el campo no se encuentre entre los valores de una lista
2285		* antes de insertar o actualizar
2286		*
2287		* <code>
2288		* $this->_validates_exclusion_of("edad", range(1, 13))
2289		* </code>
2290		*
2291		* @param string $campo
2292		* @param array $list
2293		* @return boolean
2294		*/
2295		protected function validates_exclusion_of($campo, $list){
2296		$this->_connect();
2297		if(!isset($this->_validates_exclusion[$campo])) {
2298		$this->_validates_exclusion[$campo] = get_params(func_get_args());
2299		}
2300		return true;
2301		}
2302
2303		/**
2304		* Valida que el campo tenga determinado formato segun una expresion regular
2305		* antes de insertar o actualizar
2306		*
2307		* $this->_validates_format_of("email", "^(+)@((?:[?a?z0?9]+\.)+[a?z]{2,})$")
2308		*
2309		* @param string
2310		* @param array $list
2311		* @return boolean
2312		*/
2313		protected function validates_format_of($campo, $pattern){
2314		$this->_connect();
2315		if(!isset($this->_validates_format[$campo])) {
2316		$this->_validates_format[$campo] = get_params(func_get_args());
2317		}
2318		return true;
2319		}
2320
2321		/**
2322		* Valida que ciertos atributos tengan un valor numerico
2323		* antes de insertar o actualizar
2324		*
2325		* $this->validates_numericality_of("precio")
2326		*/
2327		protected function validates_numericality_of(){
2328		$this->_connect();
2329
2330		$params = get_params(func_get_args());
2331		if(is_array($params[0])) {
2332		$params = $params[0];
2333		}
2334
2335		$fields = array();
2336		for($i=0; isset($params[$i]); $i++) {
2337		$fields[] = $params[$i];
2338		unset($params[$i]);
2339		$i++;
2340		}
2341
2342		foreach($fields as $p){
2343		if(!in_array($p, $this->fields)&&!isset($this->$p)){
2344		throw new ActiveRecordException('No se puede validar presencia de "'.$p.'"
2345		en el modelo '.$this->source.' porque no existe el atributo</u><br>
	2079	return false;
	2080	}
	2081	if (!isset($this->_validates_presence[$p])) {
	2082	$this->_validates_presence[$p] = $params;
	2083	}
	2084	}
	2085	return true;
	2086	}
	2087	/**
	2088	* Valida el tamaño de ciertos campos antes de insertar
	2089	* o actualizar
	2090	*
	2091	* @params string $field campo a validar
	2092	*
	2093	* $this->validates_length_of("nombre", "minumum: 15")
	2094	* $this->validates_length_of("nombre", "minumum: 15", "too_short: El Nombre es muy corto")
	2095	* $this->validates_length_of("nombre", "maximum: 40", "too_long: El nombre es muy largo")
	2096	* $this->validates_length_of("nombre", "in: 15:40",
	2097	* "too_short: El Nombre es muy corto",
	2098	* "too_long: El nombre es muy largo (40 min)"
	2099	* )
	2100	*
	2101	* @return boolean
	2102	*/
	2103	protected function validates_length_of($field) {
	2104	$this->_connect();
	2105	$params = get_params(func_get_args());
	2106	if (!isset($this->_validates_length[$field])) {
	2107	$this->_validates_length[$field] = $params;
	2108	}
	2109	return true;
	2110	}
	2111	/**
	2112	* Valida que el campo se encuentre entre los valores de una lista
	2113	* antes de insertar o actualizar
	2114	*
	2115	* $this->_validates_inclusion_in("estado", array("A", "I"))
	2116	*
	2117	* @param string $campo
	2118	* @param array $list
	2119	* @return boolean
	2120	*/
	2121	protected function validates_inclusion_in($campo, $list) {
	2122	$this->_connect();
	2123	if (!isset($this->_validates_inclusion[$campo])) {
	2124	$this->_validates_inclusion[$campo] = get_params(func_get_args());
	2125	}
	2126	return true;
	2127	}
	2128	/**
	2129	* Valida que el campo no se encuentre entre los valores de una lista
	2130	* antes de insertar o actualizar
	2131	*
	2132	* <code>
	2133	* $this->_validates_exclusion_of("edad", range(1, 13))
	2134	* </code>
	2135	*
	2136	* @param string $campo
	2137	* @param array $list
	2138	* @return boolean
	2139	*/
	2140	protected function validates_exclusion_of($campo, $list) {
	2141	$this->_connect();
	2142	if (!isset($this->_validates_exclusion[$campo])) {
	2143	$this->_validates_exclusion[$campo] = get_params(func_get_args());
	2144	}
	2145	return true;
	2146	}
	2147	/**
	2148	* Valida que el campo tenga determinado formato segun una expresion regular
	2149	* antes de insertar o actualizar
	2150	*
	2151	* $this->_validates_format_of("email", "^(+)@((?:[?a?z0?9]+\.)+[a?z]{2,})$")
	2152	*
	2153	* @param string
	2154	* @param array $list
	2155	* @return boolean
	2156	*/
	2157	protected function validates_format_of($campo, $pattern) {
	2158	$this->_connect();
	2159	if (!isset($this->_validates_format[$campo])) {
	2160	$this->_validates_format[$campo] = get_params(func_get_args());
	2161	}
	2162	return true;
	2163	}
	2164	/**
	2165	* Valida que ciertos atributos tengan un valor numerico
	2166	* antes de insertar o actualizar
	2167	*
	2168	* $this->validates_numericality_of("precio")
	2169	*/
	2170	protected function validates_numericality_of() {
	2171	$this->_connect();
	2172	$params = get_params(func_get_args());
	2173	if (is_array($params[0])) {
	2174	$params = $params[0];
	2175	}
	2176	$fields = array();
	2177	for ($i = 0;isset($params[$i]);$i++) {
	2178	$fields[] = $params[$i];
	2179	unset($params[$i]);
	2180	$i++;
	2181	}
	2182	foreach($fields as $p) {
	2183	if (!in_array($p, $this->fields) && !isset($this->$p)) {
	2184	throw new ActiveRecordException('No se puede validar presencia de "' . $p . '"
	2185	en el modelo ' . $this->source . ' porque no existe el atributo</u><br>
2346	2186	Verifique que el atributo este bien escrito y/o exista en la relación ');
2347		return false;
2348		}
2349		if(!isset($this->_validates_numericality[$p])){
2350		$this->_validates_numericality[$p] = $params;
2351		}
2352		}
2353		return true;
2354		}
2355
2356		/**
2357		* Valida que ciertos atributos tengan un formato de e-mail correcto
2358		* antes de insertar o actualizar
2359		*
2360		* $this->_validates_email_in("correo")
2361		*/
2362		protected function validates_email_in(){
2363		$this->_connect();
2364
2365		$params = get_params(func_get_args());
2366		if(is_array($params[0])) {
2367		$params = $params[0];
2368		}
2369
2370		$fields = array();
2371		for($i=0; isset($params[$i]); $i++) {
2372		$fields[] = $params[$i];
2373		unset($params[$i]);
2374		$i++;
2375		}
2376
2377		foreach($fields as $p){
2378		if(!in_array($p, $this->fields)&&!isset($this->$p)){
2379		throw new ActiveRecordException('No se puede validar presencia de "'.$p.'"
2380		en el modelo '.$this->source.' porque no existe el atributo</u><br>
	2187	return false;
	2188	}
	2189	if (!isset($this->_validates_numericality[$p])) {
	2190	$this->_validates_numericality[$p] = $params;
	2191	}
	2192	}
	2193	return true;
	2194	}
	2195	/**
	2196	* Valida que ciertos atributos tengan un formato de e-mail correcto
	2197	* antes de insertar o actualizar
	2198	*
	2199	* $this->_validates_email_in("correo")
	2200	*/
	2201	protected function validates_email_in() {
	2202	$this->_connect();
	2203	$params = get_params(func_get_args());
	2204	if (is_array($params[0])) {
	2205	$params = $params[0];
	2206	}
	2207	$fields = array();
	2208	for ($i = 0;isset($params[$i]);$i++) {
	2209	$fields[] = $params[$i];
	2210	unset($params[$i]);
	2211	$i++;
	2212	}
	2213	foreach($fields as $p) {
	2214	if (!in_array($p, $this->fields) && !isset($this->$p)) {
	2215	throw new ActiveRecordException('No se puede validar presencia de "' . $p . '"
	2216	en el modelo ' . $this->source . ' porque no existe el atributo</u><br>
2381	2217	Verifique que el atributo este bien escrito y/o exista en la relación ');
2382		return false;
2383		}
2384		if(!isset($this->_validates_email[$p])){
2385		$this->_validates_email[$p] = $params;
2386		}
2387		}
2388		return true;
2389		}
2390
2391		/**
2392		* Valida que ciertos atributos tengan un valor unico antes
2393		* de insertar o actualizar
2394		*
2395		* message: mensaje a mostrar
2396		* field: nombre de campo que mostrara
2397		*
2398		* $this->_validates_uniqueness_of("cedula")
2399		*/
2400		protected function validates_uniqueness_of(){
2401		$this->_connect();
2402
2403		$params = get_params(func_get_args());
2404		if(is_array($params[0])) {
2405		$params = $params[0];
2406		}
2407
2408		$fields = array();
2409		for($i=0; isset($params[$i]); $i++) {
2410		$fields[] = $params[$i];
2411		unset($params[$i]);
2412		$i++;
2413		}
2414
2415		foreach($fields as $p){
2416		if(!in_array($p, $this->fields)&&!isset($this->$p)){
2417		throw new ActiveRecordException('No se puede validar presencia de "'.$p.'"
2418		en el modelo '.$this->source.' porque no existe el atributo</u><br>
	2218	return false;
	2219	}
	2220	if (!isset($this->_validates_email[$p])) {
	2221	$this->_validates_email[$p] = $params;
	2222	}
	2223	}
	2224	return true;
	2225	}
	2226	/**
	2227	* Valida que ciertos atributos tengan un valor unico antes
	2228	* de insertar o actualizar
	2229	*
	2230	* message: mensaje a mostrar
	2231	* field: nombre de campo que mostrara
	2232	*
	2233	* $this->_validates_uniqueness_of("cedula")
	2234	*/
	2235	protected function validates_uniqueness_of() {
	2236	$this->_connect();
	2237	$params = get_params(func_get_args());
	2238	if (is_array($params[0])) {
	2239	$params = $params[0];
	2240	}
	2241	$fields = array();
	2242	for ($i = 0;isset($params[$i]);$i++) {
	2243	$fields[] = $params[$i];
	2244	unset($params[$i]);
	2245	$i++;
	2246	}
	2247	foreach($fields as $p) {
	2248	if (!in_array($p, $this->fields) && !isset($this->$p)) {
	2249	throw new ActiveRecordException('No se puede validar presencia de "' . $p . '"
	2250	en el modelo ' . $this->source . ' porque no existe el atributo</u><br>
2419	2251	Verifique que el atributo este bien escrito y/o exista en la relación ');
2420		return false;
2421		}
2422		if(!isset($this->_validates_uniqueness[$p])){
2423		$this->_validates_uniqueness[$p] = $params;
2424		}
2425		}
2426		return true;
2427		}
2428
2429		/**
2430		* Valida que ciertos atributos tengan un formato de fecha acorde al indicado en
2431		* config/config.ini antes de insertar o actualizar
2432		*
2433		* $this->_validates_date_in("fecha_registro")
2434		*/
2435		protected function validates_date_in(){
2436		$this->_connect();
2437
2438		$params = get_params(func_get_args());
2439		if(is_array($params[0])) {
2440		$params = $params[0];
2441		}
2442
2443		$fields = array();
2444		for($i=0; isset($params[$i]); $i++) {
2445		$fields[] = $params[$i];
2446		unset($params[$i]);
2447		$i++;
2448		}
2449
2450		foreach($fields as $p){
2451		if(!in_array($p, $this->fields)&&!isset($this->$p)){
2452		throw new ActiveRecordException('No se puede validar presencia de "'.$p.'"
2453		en el modelo '.$this->source.' porque no existe el atributo</u><br>
	2252	return false;
	2253	}
	2254	if (!isset($this->_validates_uniqueness[$p])) {
	2255	$this->_validates_uniqueness[$p] = $params;
	2256	}
	2257	}
	2258	return true;
	2259	}
	2260	/**
	2261	* Valida que ciertos atributos tengan un formato de fecha acorde al indicado en
	2262	* config/config.ini antes de insertar o actualizar
	2263	*
	2264	* $this->_validates_date_in("fecha_registro")
	2265	*/
	2266	protected function validates_date_in() {
	2267	$this->_connect();
	2268	$params = get_params(func_get_args());
	2269	if (is_array($params[0])) {
	2270	$params = $params[0];
	2271	}
	2272	$fields = array();
	2273	for ($i = 0;isset($params[$i]);$i++) {
	2274	$fields[] = $params[$i];
	2275	unset($params[$i]);
	2276	$i++;
	2277	}
	2278	foreach($fields as $p) {
	2279	if (!in_array($p, $this->fields) && !isset($this->$p)) {
	2280	throw new ActiveRecordException('No se puede validar presencia de "' . $p . '"
	2281	en el modelo ' . $this->source . ' porque no existe el atributo</u><br>
2454	2282	Verifique que el atributo este bien escrito y/o exista en la relación ');
2455		return false;
2456		}
2457		if(!isset($this->_validates_date[$p])){
2458		$this->_validates_date[$p] = $params;
2459		}
2460		}
2461		return true;
2462		}
2463
2464
2465		/**
2466		* Verifica si un campo es de tipo de dato numerico o no
2467		*
2468		* @param string $field
2469		* @return boolean
2470		*/
2471		public function is_a_numeric_type($field){
2472		if(strpos(" ".$this->_data_type[$field], "int") \|\| strpos(" ".$this->_data_type[$field], "decimal")
2473		\|\| strpos(" ".$this->_data_type[$field], "number")){
2474		return true;
2475		} else {
2476		return false;
2477		}
2478		}
2479
2480		/**
2481		* Obtiene los datos de los metadatos generados por Primera vez en la Sesión
2482		*
2483		* @param string $table
2484		* @return array
2485		*/
2486		static function get_meta_data($table){
2487		if(isset(self::$models[$table])){
2488		return self::$models[$table];
2489		} else {
2490		$active_app = Router::get_active_app();
2491		if(isset($_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table])){
2492		self::set_meta_data($table, $_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table]);
2493		return self::$models[$table];
2494		}
2495		return array();
2496		}
2497		}
2498
2499		/**
2500		* Crea un registro de meta datos para la tabla especificada
2501		*
2502		* @param string $table
2503		* @param array $meta_data
2504		*/
2505		static function set_meta_data($table, $meta_data){
2506		$active_app = Router::get_active_app();
2507		if(!isset($_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table])){
2508		$_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table] = $meta_data;
2509		}
2510		self::$models[$table] = $meta_data;
2511		return true;
2512		}
2513
2514		/**
2515		* Elimina la información de cache del objeto y hace que sea cargada en la proxima operación
2516		*
2517		*/
2518		public function reset_cache_information(){
2519		$active_app = Router::get_active_app();
2520		unset($_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$this->source]);
2521		$this->_dumped = false;
2522		if(!$this->is_dumped()){
2523		$this->dump();
2524		}
2525		}
2526
2527
2528		/*******************************************************************************************
2529		* Metodos para generacion de relaciones
2530		*******************************************************************************************/
2531
2532		/**
2533		* Crea una relacion 1-1 entre dos modelos
2534		*
2535		* @param string $relation
2536		*
2537		* model : nombre del modelo al que se refiere
2538		* fk : campo por el cual se relaciona (llave foranea)
2539		*/
2540		protected function has_one($relation){
2541		$params = get_params(func_get_args());
2542		for($i=0; isset($params[$i]); $i++){
2543		$relation = uncamelize(lcfirst($params[$i]));
2544		if(!array_key_exists($relation, $this->_has_one)){
2545		$this->_has_one[$relation] = new stdClass();
2546		$this->_has_one[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
2547		$this->_has_one[$relation]->fk = isset($params['fk']) ? $params['fk'] : uncamelize(lcfirst(get_class($this))).'_id';
2548		}
2549		}
2550		}
2551
2552		/**
2553		* Crea una relacion 1-1 inversa entre dos modelos
2554		*
2555		* @param string $relation
2556		*
2557		* model : nombre del modelo al que se refiere
2558		* fk : campo por el cual se relaciona (llave foranea)
2559		*/
2560		protected function belongs_to($relation){
2561		$params = get_params(func_get_args());
2562		for($i=0; isset($params[$i]); $i++){
2563		$relation = uncamelize(lcfirst($params[$i]));
2564		if(!array_key_exists($relation, $this->_belongs_to)){
2565		$this->_belongs_to[$relation] = new stdClass();
2566		$this->_belongs_to[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
2567		$this->_belongs_to[$relation]->fk = isset($params['fk']) ? $params['fk'] : "{$relation}_id";
2568		}
2569		}
2570		}
2571
2572		/**
2573		* Crea una relacion 1-n entre dos modelos
2574		*
2575		* @param string $relation
2576		*
2577		* model : nombre del modelo al que se refiere
2578		* fk : campo por el cual se relaciona (llave foranea)
2579		*/
2580		protected function has_many($relation){
2581		$params = get_params(func_get_args());
2582		for($i=0; isset($params[$i]); $i++){
2583		$relation = uncamelize(lcfirst($params[$i]));
2584		if(!array_key_exists($relation, $this->_has_many)){
2585		$this->_has_many[$relation] = new stdClass();
2586		$this->_has_many[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
2587		$this->_has_many[$relation]->fk = isset($params['fk']) ? $params['fk'] : uncamelize(lcfirst(get_class($this))).'_id';
2588		}
2589		}
2590		}
2591
2592		/**
2593		* Crea una relacion n-n o 1-n inversa entre dos modelos
2594		*
2595		* @param string $relation
2596		*
2597		* model : nombre del modelo al que se refiere
2598		* fk : campo por el cual se relaciona (llave foranea)
2599		* key: campo llave que identifica al propio modelo
2600		* through : atrav�s de que tabla
2601		*/
2602		protected function has_and_belongs_to_many($relation){
2603		$params = get_params(func_get_args());
2604		for($i=0; isset($params[$i]); $i++){
2605		$relation = uncamelize(lcfirst($params[$i]));
2606		if(!array_key_exists($relation, $this->_has_and_belongs_to_many)){
2607		$this->_has_and_belongs_to_many[$relation] = new stdClass();
2608		$this->_has_and_belongs_to_many[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
2609		$this->_has_and_belongs_to_many[$relation]->fk = isset($params['fk']) ? $params['fk'] : "{$relation}_id";
2610		$this->_has_and_belongs_to_many[$relation]->key = isset($params['key']) ? $params['key'] : uncamelize(lcfirst(get_class($this))).'_id';
2611
2612		if(isset($params['through'])) {
2613		$this->_has_and_belongs_to_many[$relation]->through = $params['through'];
2614		}
2615		}
2616		}
2617		}
2618
2619		/**
2620		* Herencia Simple
2621		*/
2622
2623		/**
2624		* Especifica que la clase es padre de otra
2625		*
2626		* @param string $parent
2627		*/
2628		public function parent_of($parent){
2629		$parents = func_get_args();
2630		foreach($parents as $parent){
2631		if(!in_array($parent, $this->parent_of)){
2632		$this->parent_of[] = $parent;
2633		}
2634		}
2635		}
2636
2637		/**
2638		* Elimina caracteres que podrian ayudar a ejecutar
2639		* un ataque de Inyeccion SQL
2640		*
2641		* @param string $sql_item
2642		*/
2643		public static function sql_item_sanizite($sql_item){
2644		$sql_item = trim($sql_item);
2645		if($sql_item!==''&&$sql_item!==null){
2646		$sql_item = ereg_replace("[ ]+", "", $sql_item);
2647		if(!ereg("^[a-zA-Z0-9_\.]+$", $sql_item)){
2648		throw new ActiveRecordException("Se esta tratando de ejecutar una operacion maliciosa!");
2649		}
2650		}
2651		return $sql_item;
2652		}
2653
2654		/**
2655		* Elimina caracteres que podrian ayudar a ejecutar
2656		* un ataque de Inyeccion SQL
2657		*
2658		* @param string $sql_item
2659		*/
2660		public static function sql_sanizite($sql_item){
2661		$sql_item = trim($sql_item);
2662		if($sql_item!==''&&$sql_item!==null){
2663		$sql_item = ereg_replace("[ ]+", "", $sql_item);
2664		if(!ereg("^[a-zA-Z_0-9\,\.\*]+$", $sql_item)){
2665		throw new ActiveRecordException("Se esta tratando de ejecutar una operacion maliciosa!");
2666		}
2667		}
2668		return $sql_item;
2669		}
2670
2671		/**
2672		* Al sobreescribir este metodo se puede controlar las excepciones de un modelo
2673		*
2674		* @param unknown_type $e
2675		*/
2676		protected function exceptions($e){
2677		throw $e;
2678		}
2679
2680		/**
2681		* Implementacion de __toString Standard
2682		*
2683		*/
2684		public function __toString(){
2685		return "<".get_class()." Object>";
2686		}
2687
2688		/**
2689		* Paginador para el modelo
2690		*
2691		* conditions: condiciones para paginacion
2692		* page: numero de pagina a mostrar (por defecto la pagina 1)
2693		* per_page: cantidad de elementos por pagina (por defecto 10 items por pagina)
2694		*
2695		* @return un objeto Page identico al que se regresa con el util paginate
2696		**/
2697		public function paginate() {
2698		$args = func_get_args();
2699		array_num_insert($args, 0, $this);
2700		return call_user_func_array('paginate', $args);
2701		}
2702
2703		/**
2704		* Paginador para el modelo atraves de consulta sql
2705		*
2706		* @param string $sql consulta sql
2707		*
2708		* page: numero de pagina a mostrar (por defecto la pagina 1)
2709		* per_page: cantidad de elementos por pagina (por defecto 10 items por pagina)
2710		*
2711		* @return un objeto Page identico al que se regresa con el util paginate_by_sql
2712		**/
2713		public function paginate_by_sql($sql) {
2714		$args = func_get_args();
2715		array_num_insert($args, 0, $this);
2716		return call_user_func_array('paginate_by_sql', $args);
2717		}
2718
	2283	return false;
	2284	}
	2285	if (!isset($this->_validates_date[$p])) {
	2286	$this->_validates_date[$p] = $params;
	2287	}
	2288	}
	2289	return true;
	2290	}
	2291	/**
	2292	* Verifica si un campo es de tipo de dato numerico o no
	2293	*
	2294	* @param string $field
	2295	* @return boolean
	2296	*/
	2297	public function is_a_numeric_type($field) {
	2298	if (strpos(" " . $this->_data_type[$field], "int") \|\| strpos(" " . $this->_data_type[$field], "decimal") \|\| strpos(" " . $this->_data_type[$field], "number")) {
	2299	return true;
	2300	} else {
	2301	return false;
	2302	}
	2303	}
	2304	/**
	2305	* Obtiene los datos de los metadatos generados por Primera vez en la Sesión
	2306	*
	2307	* @param string $table
	2308	* @return array
	2309	*/
	2310	static function get_meta_data($table) {
	2311	if (isset(self::$models[$table])) {
	2312	return self::$models[$table];
	2313	} else {
	2314	$active_app = Router::get_active_app();
	2315	if (isset($_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table])) {
	2316	self::set_meta_data($table, $_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table]);
	2317	return self::$models[$table];
	2318	}
	2319	return array();
	2320	}
	2321	}
	2322	/**
	2323	* Crea un registro de meta datos para la tabla especificada
	2324	*
	2325	* @param string $table
	2326	* @param array $meta_data
	2327	*/
	2328	static function set_meta_data($table, $meta_data) {
	2329	$active_app = Router::get_active_app();
	2330	if (!isset($_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table])) {
	2331	$_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$table] = $meta_data;
	2332	}
	2333	self::$models[$table] = $meta_data;
	2334	return true;
	2335	}
	2336	/**
	2337	* Elimina la información de cache del objeto y hace que sea cargada en la proxima operación
	2338	*
	2339	*/
	2340	public function reset_cache_information() {
	2341	$active_app = Router::get_active_app();
	2342	unset($_SESSION['KUMBIA_META_DATA'][$_SESSION['KUMBIA_PATH']][$active_app][$this->source]);
	2343	$this->_dumped = false;
	2344	if (!$this->is_dumped()) {
	2345	$this->dump();
	2346	}
	2347	}
	2348	/*******************************************************************************************
	2349	* Metodos para generacion de relaciones
	2350	*******************************************************************************************/
	2351	/**
	2352	* Crea una relacion 1-1 entre dos modelos
	2353	*
	2354	* @param string $relation
	2355	*
	2356	* model : nombre del modelo al que se refiere
	2357	* fk : campo por el cual se relaciona (llave foranea)
	2358	*/
	2359	protected function has_one($relation) {
	2360	$params = get_params(func_get_args());
	2361	for ($i = 0;isset($params[$i]);$i++) {
	2362	$relation = uncamelize(lcfirst($params[$i]));
	2363	if (!array_key_exists($relation, $this->_has_one)) {
	2364	$this->_has_one[$relation] = new stdClass();
	2365	$this->_has_one[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
	2366	$this->_has_one[$relation]->fk = isset($params['fk']) ? $params['fk'] : uncamelize(lcfirst(get_class($this))) . '_id';
	2367	}
	2368	}
	2369	}
	2370	/**
	2371	* Crea una relacion 1-1 inversa entre dos modelos
	2372	*
	2373	* @param string $relation
	2374	*
	2375	* model : nombre del modelo al que se refiere
	2376	* fk : campo por el cual se relaciona (llave foranea)
	2377	*/
	2378	protected function belongs_to($relation) {
	2379	$params = get_params(func_get_args());
	2380	for ($i = 0;isset($params[$i]);$i++) {
	2381	$relation = uncamelize(lcfirst($params[$i]));
	2382	if (!array_key_exists($relation, $this->_belongs_to)) {
	2383	$this->_belongs_to[$relation] = new stdClass();
	2384	$this->_belongs_to[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
	2385	$this->_belongs_to[$relation]->fk = isset($params['fk']) ? $params['fk'] : "{$relation}_id";
	2386	}
	2387	}
	2388	}
	2389	/**
	2390	* Crea una relacion 1-n entre dos modelos
	2391	*
	2392	* @param string $relation
	2393	*
	2394	* model : nombre del modelo al que se refiere
	2395	* fk : campo por el cual se relaciona (llave foranea)
	2396	*/
	2397	protected function has_many($relation) {
	2398	$params = get_params(func_get_args());
	2399	for ($i = 0;isset($params[$i]);$i++) {
	2400	$relation = uncamelize(lcfirst($params[$i]));
	2401	if (!array_key_exists($relation, $this->_has_many)) {
	2402	$this->_has_many[$relation] = new stdClass();
	2403	$this->_has_many[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
	2404	$this->_has_many[$relation]->fk = isset($params['fk']) ? $params['fk'] : uncamelize(lcfirst(get_class($this))) . '_id';
	2405	}
	2406	}
	2407	}
	2408	/**
	2409	* Crea una relacion n-n o 1-n inversa entre dos modelos
	2410	*
	2411	* @param string $relation
	2412	*
	2413	* model : nombre del modelo al que se refiere
	2414	* fk : campo por el cual se relaciona (llave foranea)
	2415	* key: campo llave que identifica al propio modelo
	2416	* through : atrav�s de que tabla
	2417	*/
	2418	protected function has_and_belongs_to_many($relation) {
	2419	$params = get_params(func_get_args());
	2420	for ($i = 0;isset($params[$i]);$i++) {
	2421	$relation = uncamelize(lcfirst($params[$i]));
	2422	if (!array_key_exists($relation, $this->_has_and_belongs_to_many)) {
	2423	$this->_has_and_belongs_to_many[$relation] = new stdClass();
	2424	$this->_has_and_belongs_to_many[$relation]->model = ucfirst(camelize(isset($params['model']) ? $params['model'] : $relation));
	2425	$this->_has_and_belongs_to_many[$relation]->fk = isset($params['fk']) ? $params['fk'] : "{$relation}_id";
	2426	$this->_has_and_belongs_to_many[$relation]->key = isset($params['key']) ? $params['key'] : uncamelize(lcfirst(get_class($this))) . '_id';
	2427	if (isset($params['through'])) {
	2428	$this->_has_and_belongs_to_many[$relation]->through = $params['through'];
	2429	}
	2430	}
	2431	}
	2432	}
	2433	/**
	2434	* Herencia Simple
	2435	*/
	2436	/**
	2437	* Especifica que la clase es padre de otra
	2438	*
	2439	* @param string $parent
	2440	*/
	2441	public function parent_of($parent) {
	2442	$parents = func_get_args();
	2443	foreach($parents as $parent) {
	2444	if (!in_array($parent, $this->parent_of)) {
	2445	$this->parent_of[] = $parent;
	2446	}
	2447	}
	2448	}
	2449	/**
	2450	* Elimina caracteres que podrian ayudar a ejecutar
	2451	* un ataque de Inyeccion SQL
	2452	*
	2453	* @param string $sql_item
	2454	*/
	2455	public static function sql_item_sanizite($sql_item) {
	2456	$sql_item = trim($sql_item);
	2457	if ($sql_item !== '' && $sql_item !== null) {
	2458	$sql_item = ereg_replace("[ ]+", "", $sql_item);
	2459	if (!ereg("^[a-zA-Z0-9_\.]+$", $sql_item)) {
	2460	throw new ActiveRecordException("Se esta tratando de ejecutar una operacion maliciosa!");
	2461	}
	2462	}
	2463	return $sql_item;
	2464	}
	2465	/**
	2466	* Elimina caracteres que podrian ayudar a ejecutar
	2467	* un ataque de Inyeccion SQL
	2468	*
	2469	* @param string $sql_item
	2470	*/
	2471	public static function sql_sanizite($sql_item) {
	2472	$sql_item = trim($sql_item);
	2473	if ($sql_item !== '' && $sql_item !== null) {
	2474	$sql_item = ereg_replace("[ ]+", "", $sql_item);
	2475	if (!ereg("^[a-zA-Z_0-9\,\.\*]+$", $sql_item)) {
	2476	throw new ActiveRecordException("Se esta tratando de ejecutar una operacion maliciosa!");
	2477	}
	2478	}
	2479	return $sql_item;
	2480	}
	2481	/**
	2482	* Al sobreescribir este metodo se puede controlar las excepciones de un modelo
	2483	*
	2484	* @param unknown_type $e
	2485	*/
	2486	protected function exceptions($e) {
	2487	throw $e;
	2488	}
	2489	/**
	2490	* Implementacion de __toString Standard
	2491	*
	2492	*/
	2493	public function __toString() {
	2494	return "<" . get_class() . " Object>";
	2495	}
	2496	/**
	2497	* Paginador para el modelo
	2498	*
	2499	* conditions: condiciones para paginacion
	2500	* page: numero de pagina a mostrar (por defecto la pagina 1)
	2501	* per_page: cantidad de elementos por pagina (por defecto 10 items por pagina)
	2502	*
	2503	* @return un objeto Page identico al que se regresa con el util paginate
	2504	*
	2505	*/
	2506	public function paginate() {
	2507	$args = func_get_args();
	2508	array_num_insert($args, 0, $this);
	2509	return call_user_func_array('paginate', $args);
	2510	}
	2511	/**
	2512	* Paginador para el modelo atraves de consulta sql
	2513	*
	2514	* @param string $sql consulta sql
	2515	*
	2516	* page: numero de pagina a mostrar (por defecto la pagina 1)
	2517	* per_page: cantidad de elementos por pagina (por defecto 10 items por pagina)
	2518	*
	2519	* @return un objeto Page identico al que se regresa con el util paginate_by_sql
	2520	*
	2521	*/
	2522	public function paginate_by_sql($sql) {
	2523	$args = func_get_args();
	2524	array_num_insert($args, 0, $this);
	2525	return call_user_func_array('paginate_by_sql', $args);
	2526	}
2719	2527	}
2720
2721	2528	?>

Kumbia PHP Framework

Context Navigation

Changeset 337

Legend:

0.5/library/kumbia/db/active_record_base/active_record_base.php

Download in other formats: