1: <?php
2:
3: /**
4: * Copyright 2015 AutEne.com.
5: *
6: * This work is licensed under the
7: * Creative Commons Attribution-NonCommercial-NoDerivs 3.0 Unported License.
8: * To view a copy of this license, visit
9: *
10: * http://creativecommons.org/licenses/by-nc-nd/3.0/
11: *
12: * or send a letter to Creative Commons, 444 Castro Street, Suite 900,
13: * Mountain View, California, 94041, USA.
14: * Unless required by applicable law or agreed to in writing, software
15: * distributed under the License is distributed on an "AS IS" BASIS,
16: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17: * See the License for the specific language governing permissions and
18: * limitations under the License.
19: */
20:
21: /**
22: * Incluimos las lilbrerías necesarias. Xajax y clases.
23: */
24: require_once('Provincia.php');
25: require_once('Latitud.php');
26: require_once('Periodo.php');
27: require_once('Radiacion.php');
28: require_once('Sistema.php');
29: require_once('Panel.php');
30: require_once('Historial.php');
31:
32: /**
33: * Description of Dao
34: *
35: * La clase Dao.php gestiona las conexiones a la base de datos y los métodos
36: * que implementan las consultas SQL necesarias para la obtención de los datos
37: * y la persistencia de los mismos.
38: *
39: * @author antonio horrillo horrillo
40: */
41: class Dao {
42:
43: /**
44: * protected static function ejecutaConsulta($sql)
45: *
46: * Realiza la conexión a la base de datos mediante PDO, especificando el
47: * servidor, nombre de la base de datos, usuario y contraseña de la misma.
48: * Devuelve el resultado de la consulta que tiene como parámetro de entrada.
49: *
50: * @param type $sql
51: * @return type
52: */
53: protected static function ejecutaConsulta($sql) {
54: $opc = array(PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES utf8");
55: $dsn = "mysql:host=db604256230.db.1and1.com;dbname=db604256230";
56: $usuario = 'dbo604256230';
57: $contrasena = 'sqlinefex2011';
58: $autene = new PDO($dsn, $usuario, $contrasena, $opc);
59: $resultado = null;
60: if (isset($autene)) {
61: $resultado = $autene->query($sql);
62: }
63: return $resultado;
64: }
65:
66: /**
67: * public static function obtieneLatitud()
68: *
69: * Obtenemos los valores de latitud de las provincias.
70: *
71: * Definimos la consulta sql y la enviamos como parametro al método propio
72: * de la clase Dao:
73: * self::ejecutaConsulta ($sql);
74: * Si tiene datos, mediante fetch obtenemos las filas devueltas en la consulta
75: * y creamos un objeto Latitud por cada fila. Finalmente almacenamos todos
76: * los objetos en el array $latitud y lo retornamos.
77: *
78: * @return \Latitud
79: */
80: public static function obtieneLatitud() {
81: $sql = "SELECT * FROM aut_ciu_lat;";
82: $resultado = self::ejecutaConsulta ($sql);
83: $latitud = array();
84: if($resultado) {
85: $row = $resultado->fetch();
86: while ($row != null) {
87: $latitud[] = new Latitud($row);
88: $row = $resultado->fetch();
89: }
90: }
91: return $latitud;
92: }
93:
94: /**
95: * public static function obtienePeriodo()
96: *
97: * Obtenemos los valores del Periodo de Cálculo.
98: *
99: * Definimos la consulta sql y la enviamos como parametro al método propio
100: * de la clase Dao:
101: * self::ejecutaConsulta ($sql);
102: * Si tiene datos, mediante fetch obtenemos las filas devueltas en la consulta
103: * y creamos un objeto Periodo por cada fila. Finalmente almacenamos todos
104: * los objetos en el array $periodo y lo retornamos.
105: *
106: * @return \Periodo
107: */
108: public static function obtienePeriodo() {
109: $sql = "SELECT * FROM aut_per_cal;";
110: $resultado = self::ejecutaConsulta ($sql);
111: $periodo = array();
112: if($resultado) {
113: $row = $resultado->fetch();
114: while ($row != null) {
115: $periodo[] = new Periodo($row);
116: $row = $resultado->fetch();
117: }
118: }
119: return $periodo;
120: }
121:
122: /**
123: * public static function obtieneRadiacion()
124: *
125: * Obtenemos los valores de Radiación Horizontal Mensual por provincia.
126: *
127: * Definimos la consulta sql y la enviamos como parametro al método propio
128: * de la clase Dao:
129: * self::ejecutaConsulta ($sql);
130: * Si tiene datos, mediante fetch obtenemos las filas devueltas en la consulta
131: * y creamos un objeto Radiación por cada fila. Finalmente almacenamos todos
132: * los objetos en el array $radiación y lo retornamos.
133: *
134: * @return \Radiacion
135: */
136: public static function obtieneRadiacion() {
137: $sql = "SELECT * FROM aut_rad_hor;";
138: $resultado = self::ejecutaConsulta ($sql);
139: $radiacion = array();
140: if($resultado) {
141: $row = $resultado->fetch();
142: while ($row != null) {
143: $radiacion[] = new Radiacion($row);
144: $row = $resultado->fetch();
145: }
146: }
147: return $radiacion;
148: }
149:
150: /**
151: * public static function obtieneSistema()
152: *
153: * Obtenemos los Tipos de Sistemas y sus Factores Pr.
154: *
155: * Definimos la consulta sql y la enviamos como parametro al método propio
156: * de la clase Dao:
157: * self::ejecutaConsulta ($sql);
158: * Si tiene datos, mediante fetch obtenemos las filas devueltas en la consulta
159: * y creamos un objeto Sistema por cada fila. Finalmente almacenamos todos
160: * los objetos en el array $sistema y lo retornamos.
161: *
162: * @return \Sistema
163: */
164: public static function obtieneSistema() {
165: $sql = "SELECT * FROM aut_efi_sis;";
166: $resultado = self::ejecutaConsulta ($sql);
167: $sistema = array();
168: if($resultado) {
169: $row = $resultado->fetch();
170: while ($row != null) {
171: $sistema[] = new Sistema($row);
172: $row = $resultado->fetch();
173: }
174: }
175: return $sistema;
176: }
177:
178: /**
179: * public static function obtienePanel()
180: *
181: * Obtenemos la información de los Módulos Solares disponibles en la base de datos.
182: *
183: * Definimos la consulta sql y la enviamos como parametro al método propio
184: * de la clase Dao:
185: * self::ejecutaConsulta ($sql);
186: * Si tiene datos, mediante fetch obtenemos las filas devueltas en la consulta
187: * y creamos un objeto Panel por cada fila. Finalmente almacenamos todos
188: * los objetos en el array $panel y lo retornamos.
189: *
190: * @return \Panel
191: */
192: public static function obtienePanel() {
193: $sql = "SELECT * FROM aut_dat_pan;";
194: $resultado = self::ejecutaConsulta ($sql);
195: $panel = array();
196: if($resultado) {
197: $row = $resultado->fetch();
198: while ($row != null) {
199: $panel[] = new Panel($row);
200: $row = $resultado->fetch();
201: }
202: }
203: return $panel;
204: }
205:
206: /**
207: * public static function verificaNombre($nombre)
208: *
209: * Verificamos el nombre de usuario en la base de datos para iniciar sesión.
210: *
211: * Definimos la consulta sql y la enviamos como parametro al método propio
212: * de la clase Dao:
213: * self::ejecutaConsulta ($sql);
214: * Definimos la variable $verificado y le asignamos el valor false. Si tiene
215: * datos la consulta, mediante fetch obtenemos la fila devuelta en la consulta,
216: * existe un registro que cumpla la condición, tenemos usuario registrado,
217: * por lo que asignamos el valor de $verificado a true y la retornamos. Si
218: * no tenemos datos, retornamos el valor inicial de $verificado, el valor false
219: * lo que indica que no existe un registro con ese usuario.
220: *
221: * @param type $nombre
222: * @return boolean
223: */
224: public static function verificaNombre($nombre) {
225: $sql = "SELECT usuario FROM aut_use_log ";
226: $sql .= "WHERE usuario='".$nombre."';";
227: $resultado = self::ejecutaConsulta ($sql);
228: $verificado = false;
229: if(isset($resultado)) {
230: $fila = $resultado->fetch();
231: if($fila !== false) {
232: $verificado=true;
233: }
234: }
235: return $verificado;
236: }
237:
238: /**
239: * public static function obtieneClave($nombre)
240: *
241: * Retornamos la clave del usuario especificado para iniciar sesión.
242: *
243: * Definimos la consulta sql y la enviamos como parametro al método propio
244: * de la clase Dao:
245: * self::ejecutaConsulta ($sql);
246: * Si tiene datos, mediante fetch obtenemos la fila devuelta en la consulta
247: * y asignamos a $clave el valor del la celda $row['clave'], que contene la
248: * contraseña del usuario. Finalmente retornamos $clave.
249: *
250: * @param type $nombre
251: * @return type
252: */
253: public static function obtieneClave($nombre) {
254: $sql = "SELECT clave FROM aut_use_log ";
255: $sql .= "WHERE usuario='".$nombre."';";
256: $resultado = self::ejecutaConsulta ($sql);
257: $clave = array();
258: if(isset($resultado)) {
259: $row = $resultado->fetch();
260: $clave = $row['clave'];
261: }
262: return $clave;
263: }
264:
265: /**
266: * public static function grabarDatos($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles)
267: *
268: * Grabamos los datos del Resumen del Cálculo en la base de datos.
269: *
270: * Si las variables $usu, $ed, $prov, $pmp_min, $pmp_max, $panel, $paneles
271: * estan definidas y no son null, definimos la consulta sql y la enviamos
272: * como parametro al método propio de la clase Dao:
273: * self::ejecutaConsulta ($sql);
274: * Este método realiza la inserción de la fila en la base de datos. Si alguna
275: * de las variables no estuviera definida correctamente, no se realiza la
276: * inserción de la fila en la tabla.
277: *
278: * @param type $usu
279: * @param type $ed
280: * @param type $prov
281: * @param type $pmp_min
282: * @param type $pmp_max
283: * @param type $panel
284: * @param type $paneles
285: */
286: public static function grabarDatos($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles) {
287: if (isset($usu) && isset($ed) && isset($prov) && isset($pmp_min) && isset($pmp_max) && isset($panel) && isset($paneles)) {
288: $sql = "INSERT INTO `aut_use_cal` (`Usuario`, `Ed`, `Provincia`,";
289: $sql.="`Pmpmin`, `Pmpmax`, `Panel`, `Modulos`) VALUES ('".$usu."', '".$ed."',";
290: $sql.="'".$prov."', '".$pmp_min."', '".$pmp_max."', '".$panel."', '".$paneles."')";
291: self::ejecutaConsulta ($sql);
292: }
293: }
294:
295: /**
296: * public static function verificaResumen($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles)
297: *
298: * Verificamos si el registro se encuentra en la base de datos o no.
299: *
300: * Definimos la consulta sql y la enviamos como parametro al método propio
301: * de la clase Dao:
302: * self::ejecutaConsulta ($sql);
303: * Definimos la variable $verificado y le asignamos el valor false. Si tiene
304: * datos la consulta, mediante fetch obtenemos la fila devuelta en la consulta,
305: * existe un registro que cumpla la condición, lo que significa que ya tenemos
306: * el calculo del panel registrado en la base de datos, por lo que asignamos
307: * el valor de $verificado a true y la retornamos. Si no tenemos datos,
308: * retornamos el valor inicial de $verificado, el valor false lo que indica
309: * que no existe un registro con el calculo del panel registrado.
310: *
311: * @param type $usu
312: * @param type $ed
313: * @param type $prov
314: * @param type $pmp_min
315: * @param type $pmp_max
316: * @param type $panel
317: * @param type $paneles
318: * @return boolean
319: */
320: public static function verificaResumen($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles) {
321: $sql = "SELECT usuario FROM `aut_use_cal` WHERE `Usuario`='".$usu."' AND ";
322: $sql.= " `Ed`='".$ed."' AND `Provincia`='".$prov."' AND `Pmpmin`='".$pmp_min."' AND ";
323: $sql.=" `Pmpmax`='".$pmp_max."' AND `Panel`='".$panel."' AND `Modulos`='".$paneles."'";
324: $resultado = self::ejecutaConsulta ($sql);
325: $verificado = false;
326: if(isset($resultado)) {
327: $fila = $resultado->fetch();
328: if($fila !== false) {
329: $verificado=true;
330: }
331: }
332: return $verificado;
333: }
334:
335: /**
336: * public static function obtieneHistorial()
337: *
338: * Obtenemos el Historial de Cálculos de los Módulos Solares.
339: *
340: * Definimos la consulta sql y la enviamos como parametro al método propio
341: * de la clase Dao:
342: * self::ejecutaConsulta ($sql);
343: * Si tiene datos, mediante fetch obtenemos las filas devueltas en la consulta
344: * y creamos un objeto Historial por cada fila. Finalmente almacenamos todos
345: * los objetos en el array $historial y lo retornamos.
346: *
347: * @return \Historial
348: */
349: public static function obtieneHistorial() {
350: $sql = "SELECT * FROM aut_use_cal;";
351: $resultado = self::ejecutaConsulta ($sql);
352: $historial = array();
353: if($resultado) {
354: $row = $resultado->fetch();
355: while ($row != null) {
356: $historial[] = new Historial($row);
357: $row = $resultado->fetch();
358: }
359: }
360: return $historial;
361: }
362: }
363:
364: ?>