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 librerías necesarias.
23: */
24: require_once('./include/xajax/xajax_core/xajax.inc.php');
25: require_once('../modelo/Dao.php');
26: require_once('../modelo/Elemento.php');
27: require_once('../modelo/Irradiacion.php');
28:
29: /**
30: * Recuperamos la informacion de la sesion.
31: */
32: session_start();
33:
34: /**
35: * Creamos el objeto Xajax.
36: */
37: $xajax = new xajax();
38:
39: /**
40: * Registramos las funciones que vamos a llamar desde JavaScript o directamente
41: * desde el codigo PHP.
42: */
43: $xajax->register(XAJAX_FUNCTION, "login");
44: $xajax->register(XAJAX_FUNCTION, "agregar_elemento");
45: $xajax->register(XAJAX_FUNCTION, "borrar_elementos");
46: $xajax->register(XAJAX_FUNCTION, "latitud");
47: $xajax->register(XAJAX_FUNCTION, "borrar_latitud");
48: $xajax->register(XAJAX_FUNCTION, "periodo");
49: $xajax->register(XAJAX_FUNCTION, "borrar_periodo");
50: $xajax->register(XAJAX_FUNCTION, "irradiacion");
51: $xajax->register(XAJAX_FUNCTION, "borrar_irradiacion");
52: $xajax->register(XAJAX_FUNCTION, "sombra");
53: $xajax->register(XAJAX_FUNCTION, "borrar_sombra");
54: $xajax->register(XAJAX_FUNCTION, "radiacion");
55: $xajax->register(XAJAX_FUNCTION, "borrar_radiacion");
56: $xajax->register(XAJAX_FUNCTION, "gdm_ab");
57: $xajax->register(XAJAX_FUNCTION, "borrar_gdm_ab");
58: $xajax->register(XAJAX_FUNCTION, "sistema");
59: $xajax->register(XAJAX_FUNCTION, "borrar_sistema");
60: $xajax->register(XAJAX_FUNCTION, "pmp_min_pmp_max");
61: $xajax->register(XAJAX_FUNCTION, "borrar_pmp_min_pmp_max");
62: $xajax->register(XAJAX_FUNCTION, "panel");
63: $xajax->register(XAJAX_FUNCTION, "borrar_panel");
64: $xajax->register(XAJAX_FUNCTION, "resumen");
65: $xajax->register(XAJAX_FUNCTION, "borrar_resumen");
66: $xajax->register(XAJAX_FUNCTION, "grabar_resumen");
67: $xajax->register(XAJAX_FUNCTION, "historial");
68: $xajax->register(XAJAX_FUNCTION, "limpiar_historial");
69:
70: /**
71: * El método processRequest procesa las peticiones que llegan a la página.
72: * Debe ser llamado antes del código HTML
73: */
74: $xajax->processRequest();
75:
76: ////////////////////////////////////////////////////////////////////////////////
77: // Proceso de Inicio de Sesión.
78: ////////////////////////////////////////////////////////////////////////////////
79:
80: /**
81: * Función login()
82: *
83: * Validamos el nombre y contraseña enviados.
84: *
85: * Con esta función gestionamos el inicio de sesión en la aplicación. Comprueba
86: * que los campos no esten vacíos y en caso de no estarlo, si los datos de
87: * dichos campos se corresponden con los datos almacenados en la base de datos.
88: * En caso de existir correspondencia, se produce un login correcto. En caso
89: * contrario, un login inválido. Retornamos ademas el valor true o false función
90: * del éxito o no del proceso.
91: *
92: * Función php login($usu, $cla) llamada desde javascript function login() con xajax
93: * que a su vez se invoca desde el formulario id="login" con onsubmit='return login();'.
94: *
95: * @param type $usu
96: * @param type $cla
97: * @return \xajaxResponse
98: */
99: function login($usu, $cla) {
100: $respuesta = new xajaxResponse();
101: if (empty($usu) || empty($cla)) {
102: $respuesta->setReturnValue(false);
103: } else {
104: if (Dao::verificaNombre($usu)) {
105: $respuesta->assign("usuario", "className", "validate valid");
106: if ((Dao::obtieneClave($usu)) == md5($cla)) {
107: $_SESSION['usuario'] = $usu;
108: $respuesta->assign("clave", "className", "validate valid");
109: $respuesta->setReturnValue(true);
110: } else {
111: $respuesta->assign("clave", "className", "validate invalid");
112: $respuesta->setReturnValue(false);
113: }
114: } else {
115: $respuesta->assign("usuario", "className", "validate invalid");
116: $respuesta->assign("clave", "className", "disabled");
117: $respuesta->setReturnValue(false);
118: }
119: } return $respuesta;
120: }
121:
122: ////////////////////////////////////////////////////////////////////////////////
123: // Consumo de la Instalación.
124: ////////////////////////////////////////////////////////////////////////////////
125:
126: /**
127: * Función agregar_elemento($form_entrada)
128: *
129: * Introducimos los elementos de la instalación.
130: *
131: * Comprueba que las variables no esten vacías, y en caso de no estarlo, crea
132: * un nuevo objeto de la clase Elemento y lo guarda en el Array Almacen.
133: * Mediante un foreach recorremos el Array y generamos una estructura de filas y
134: * columnas que devolveremos en una cadena string $lista mediante xajax y lo
135: * dibujaremos en la vista. También dibujamos la cadena string mediante xajax de
136: * la potencia total. Retornamos además el valor true o false función del éxito
137: * o no del proceso.
138: *
139: * Función php agregar_elemento($form_entrada) llamada desde javascript function
140: * elemento() con xajax que a su vez se invoca desde el formulario id='consumo'
141: * con javascript:elemento();.
142: *
143: * @param type $form_entrada
144: * @return \xajaxResponse
145: */
146: function agregar_elemento($form_entrada) {
147: $respuesta = new xajaxResponse();
148: $lista = "";
149: if (empty($form_entrada["tipo"]) || empty($form_entrada["potencia"]) ||
150: empty($form_entrada["voltaje"]) || empty($form_entrada["horas"]) ||
151: empty($form_entrada["unidades"]) || empty($form_entrada["acdc"])) {
152: $respuesta->setReturnValue(false);
153: } else {
154: $_SESSION['almacen'][] = new Elemento($form_entrada["tipo"],
155: $form_entrada["potencia"],$form_entrada["voltaje"]." ".$form_entrada["acdc"],
156: $form_entrada["horas"], $form_entrada["unidades"]);
157: $almacen = $_SESSION['almacen'];
158: foreach ($almacen as $p) {
159: $lista.="<tr><td>" . $p->getTipo() . "</td>";
160: $lista.="<td>" . $p->getPotencia() . "</td>";
161: $lista.="<td>" . $p->getVoltaje() . "</td>";
162: $lista.="<td>" . $p->getHoras() . "</td>";
163: $lista.="<td>" . $p->getUnidades() . "</td>";
164: $lista.="<td>" . $p->getEnergia() . "</td></tr>";
165: $respuesta->assign("listado", "innerHTML", $lista);
166: }
167: $lista2 = mostrar_energia_total_ch($almacen);
168: $respuesta->append("listado", "innerHTML", $lista2);
169: $respuesta->setReturnValue(true);
170: } return $respuesta;
171: }
172:
173: /**
174: * Función mostrar_energia_total_ch($almacen)
175: *
176: * Calculamos la energía total de los elementos de la instalación.
177: *
178: * Recibimos el array $almacen con los elementos y los recorremos. De cada
179: * elemento obtenemos la energia que consume, la dividimos por 1000 para convertir
180: * a kW, y sumamos el valor a la variable $energia_total. Guardamos el valor
181: * en la variable de sesión $_SESSION['energia_total'] y finalmente componemos
182: * la variable string $lista2 la cual retornamos. Mediante number_format()
183: * ajustamosel formato del número a mostrar.
184: *
185: * Función php mostrar_energia_total_ch($almacen) es invocada directamente desde
186: * agregar_elemento($form_entrada).
187: *
188: * @param type $almacen
189: * @return string
190: */
191: function mostrar_energia_total_ch($almacen) {
192: $energia_total = 0;
193: foreach($almacen as $e) {
194: $energia_total += $e->getEnergia()/1000;
195: }
196: $_SESSION['energia_total'] = $energia_total;
197: $lista2 = "<tr><th class='red-text text-lighten-2 center flow-text' colspan='6'>";
198: $lista2 .= "Energía Total Ed: " . number_format($energia_total, 5, '.', '');
199: $lista2 .= " kWh/día</th></tr>";
200: return $lista2;
201: }
202:
203: /**
204: * Función borrar_elementos()
205: *
206: * Borramos las variables y los elementos de la instalación.
207: *
208: * Realizamos unset a las variables de sesión almacen y energia_total y vaciamos
209: * el div html que dibuja la tabla con los elementos y la energia total. Ademas
210: * mostramos un mensaje de confirmación.
211: *
212: * Función php borrar_elementos() llamada con xajax desde la tabla de elementos
213: * con onclick="xajax_borrar_elementos()".
214: *
215: * @return \xajaxResponse
216: */
217: function borrar_elementos() {
218: $respuesta = new xajaxResponse();
219: unset($_SESSION['almacen']);
220: unset($_SESSION['energia_total']);
221: $respuesta->assign("listado", "innerHTML", "");
222: $respuesta->call('alerta_elementos_borrados()');
223: $respuesta->setReturnValue(true);
224: return $respuesta;
225: }
226:
227: ////////////////////////////////////////////////////////////////////////////////
228: // Obtención de la Latitud. Elección de la Provincia.
229: ////////////////////////////////////////////////////////////////////////////////
230:
231: /**
232: * Función latitud($form_entrada)
233: *
234: * Obtenemos la latitud de la provincia seleccionada en el menú desplegable.
235: *
236: * Comprueba que la variable $form_entrada["provincia"] no este vacía, y en caso
237: * de no estarlo, mediante un foreach recorremos el Array $_SESSION['lat'] y
238: * cuando se cumple la condicion de igualdad en las provincias, guardamos en
239: * dos variables de sesion la latitud y la provincia seleccionada. Para la salida
240: * generamos una estructura de filas y columnas que devolveremos en una cadena
241: * string $lista mediante xajax y lo dibujaremos en la vista. También dibujamos
242: * la variable string de sesión $_SESSION['provincia'] mediante xajax en los
243: * div de radiación y modal de radiación. Finalmente mostramos un mensaje.
244: *
245: * Función php latitud($form_entrada) llamada con xajax desde el formulario
246: * id='latitud' con onclick="xajax_latitud(xajax.getFormValues('latitud'))"
247: *
248: * @param type $form_entrada
249: * @return \xajaxResponse
250: */
251: function latitud($form_entrada) {
252: $respuesta = new xajaxResponse();
253: if (empty($form_entrada["provincia"])) {
254: $respuesta->call('alerta_no_provincia()');
255: } else {
256: foreach ($_SESSION['lat'] as $l) {
257: if ($l->getProvincia() == $form_entrada["provincia"]) {
258: $_SESSION['lat_φ'] = $l->getLatitud();
259: $_SESSION['provincia'] = $l->getProvincia();
260: $lista = "";
261: $lista.="<tr><td>" . $l->getProvincia() . "</td>";
262: $lista.="<td>" . $l->getLatitud() . "</td></tr>";
263: $respuesta->assign("listado_latitud", "innerHTML", $lista);
264: $respuesta->assign("prov_rad_div","innerHTML",$_SESSION['provincia']);
265: $respuesta->assign("prov_rad_div_md","innerHTML",$_SESSION['provincia']);
266: $respuesta->call('alerta_si_provincia()');
267: }
268: }
269: } return $respuesta;
270: }
271:
272: /**
273: * Función borrar_latitud()
274: *
275: * Borramos las variables de sesión de latitud y provincia.
276: *
277: * Realizamos unset a las variables de sesión latitud y provincia y vaciamos
278: * el div html que dibuja la tabla con las provincias y latitudes y los div en
279: * el apartado de radiación. Ademas mostramos un mensaje de confirmación.
280: *
281: * Función php borrar_latitud() llamada con xajax desde la tabla de latitud
282: * con onclick="xajax_borrar_latitud()".
283: *
284: * @return \xajaxResponse
285: */
286: function borrar_latitud() {
287: $respuesta = new xajaxResponse();
288: unset($_SESSION['lat_φ']);
289: unset($_SESSION['provincia']);
290: $respuesta->assign("listado_latitud", "innerHTML", "");
291: $respuesta->assign("prov_rad_div","innerHTML","");
292: $respuesta->assign("prov_rad_div_md","innerHTML","");
293: $respuesta->call('alerta_latitud_borrada()');
294: return $respuesta;
295: }
296:
297: ////////////////////////////////////////////////////////////////////////////////
298: // Periodo de Cálculo.
299: ////////////////////////////////////////////////////////////////////////////////
300:
301: /**
302: * Función periodo($form_entrada)
303: *
304: * Obtenemos el Factor K y la βopt del periodo de cálculo seleccionado con el
305: * menú desplegable, en función de la latitud de la provincia elegida.
306: *
307: * Comprueba que las variables $_SESSION['lat_φ'] y $form_entrada["periodo_calculo"]
308: * no esten vacías, y en caso de no estarlo, mediante un foreach recorremos el
309: * Array ($_SESSION['per'] y cuando se cumple la condicion de igualdad en el
310: * periodo de cálculo, guardamos en dos variables de sesion el factor K y la βopt.
311: * La βopt es la suma aritmética de la latitud de la provincia y el factor F.
312: * Para la salida generamos una estructura de filas y columnas que devolveremos
313: * en una cadena string $lista mediante xajax y lo dibujaremos en la vista.
314: * Finalmente mostramos un mensaje.
315: *
316: * Función php periodo($form_entrada) llamada con xajax desde el formulario
317: * id='periodo' onclick="xajax_periodo(xajax.getFormValues('periodo'))"
318: *
319: * @param type $form_entrada
320: * @return \xajaxResponse
321: */
322: function periodo($form_entrada) {
323: $respuesta = new xajaxResponse();
324: if (empty($_SESSION['lat_φ']) || empty($form_entrada["periodo_calculo"])) {
325: $respuesta->call('alerta_no_periodo_calculo()');
326: } else {
327: foreach ($_SESSION['per'] as $p) {
328: if ($p->getPeriodo() == $form_entrada["periodo_calculo"]) {
329: $_SESSION['fk'] = $p->getK();
330: $_SESSION['per_βopt'] = $_SESSION['lat_φ'] + $p->getF();
331: $lista = "";
332: $lista.="<tr><td>" . $p->getPeriodo() . "</td>";
333: $lista.="<td>" . $_SESSION['fk'] . "</td>";
334: $lista.="<td>" . $_SESSION['per_βopt'] . "</td></tr>";
335: $respuesta->assign("listado_periodo", "innerHTML", $lista);
336: $respuesta->call('alerta_si_periodo_calculo()');
337: }
338: }
339: } return $respuesta;
340: }
341:
342: /**
343: * Función borrar_periodo()
344: *
345: * Borramos las variables de sesión factor K y βopt.
346: *
347: * Realizamos unset a las variables de sesión factor K y βopt y vaciamos
348: * el div html que dibuja la tabla con el Factor K, la βopt y el periodo de
349: * cálculo seleccionado Ademas mostramos un mensaje de confirmación.
350: *
351: * Función php borrar_periodo() llamada con xajax desde la tabla de periodo
352: * con onclick="xajax_borrar_periodo()".
353: *
354: * @return \xajaxResponse
355: */
356: function borrar_periodo() {
357: $respuesta = new xajaxResponse();
358: unset($_SESSION['fk']);
359: unset($_SESSION['per_βopt']);
360: $respuesta->assign("listado_periodo", "innerHTML", "");
361: $respuesta->call('alerta_periodo_borrado()');
362: return $respuesta;
363: }
364:
365: ////////////////////////////////////////////////////////////////////////////////
366: // Factor de Irraciación.
367: ////////////////////////////////////////////////////////////////////////////////
368:
369: /**
370: * Función irradiacion($form_entrada)
371: *
372: * Introducimos los valores de Azimut(αº) e Inclinación(βº).
373: *
374: * Comprueba las variables $α, $β con isset y $φ, $βopt con empty, y en caso de
375: * no estarlo, crea un nuevo objeto de la clase Irradiacion($φ, $α, $β, $βopt)
376: * y obtenemos el valor del Factor Irradiacion Fi, asignándolo a la variable de
377: * sesión $_SESSION['fi']. El valor de Fi se calcula dentro de la clase Irradiación
378: * y lo obtenemos con su metodo Get $irra->getFi(). Para la salida generamos una
379: * estructura de filas y columnas que devolveremos en una cadena string $lista
380: * mediante xajax y lo dibujaremos en la vista. Finalmente devolvemos true. En el
381: * caso de no cumlirse la condición inicial devolvemos false.
382: *
383: * Función php irradiacion($form_entrada) llamada desde javascript function
384: * irradiacion() con xajax que a su vez se invoca desde el formulario id='irradiacion'
385: * con action="javascript:irradiacion();".
386: *
387: * @param type $form_entrada
388: * @return \xajaxResponse
389: */
390: function irradiacion($form_entrada) {
391: $respuesta = new xajaxResponse();
392: $α = $form_entrada["azimut"];
393: $β = $form_entrada["inclinacion"];
394: $φ = $_SESSION['lat_φ'];
395: $βopt = $_SESSION['per_βopt'];
396: if (!isset($α) || !isset($β) || empty($φ) || empty($βopt)) {
397: $respuesta->setReturnValue(false);
398: } else {
399: $irra = new Irradiacion($φ, $α, $β, $βopt);
400: $_SESSION['fi'] = number_format($irra->getFi(), 5, '.', '');
401: $lista = "";
402: $lista.="<tr><td>" . $irra->getα() . "</td>";
403: $lista.="<td>" . $irra->getβ() . "</td>";
404: $lista.="<td>" . number_format($irra->getFi(), 5, '.', '') . "</td></tr>";
405: $respuesta->assign("listado_irradiacion", "innerHTML", $lista);
406: $respuesta->setReturnValue(true);
407: } return $respuesta;
408: }
409:
410: /**
411: * Función borrar_irradiacion()
412: *
413: * Borramos la variable de sesión $_SESSION['fi'].
414: *
415: * Realizamos unset a la variable de sesión $_SESSION['fi'] y vaciamos
416: * el div html que dibuja la tabla con el Azimut(αº), Inclinación(βº) y FI.
417: * Ademas mostramos un mensaje de confirmación.
418: *
419: * Función php borrar_irradiacion() llamada con xajax desde la tabla de irradiación
420: * con onclick="xajax_borrar_irradiacion()".
421: *
422: * @return \xajaxResponse
423: */
424: function borrar_irradiacion() {
425: $respuesta = new xajaxResponse();
426: unset($_SESSION['fi']);
427: $respuesta->assign("listado_irradiacion", "innerHTML", "");
428: $respuesta->call('alerta_factor_irradiacion_borrado()');
429: return $respuesta;
430: }
431:
432: ////////////////////////////////////////////////////////////////////////////////
433: // Factor de Sombra.
434: ////////////////////////////////////////////////////////////////////////////////
435:
436: /**
437: * Función sombra($form_entrada)
438: *
439: * Introducimos el factor de sombra en el input type="range".
440: *
441: * Comprueba que la variable $fs no esté vacía, y en caso de no estarlo, lo
442: * asignamos a la variable de sesión $_SESSION['fs']. Para la salida generamos una
443: * estructura de filas y columnas que devolveremos en una cadena string $lista
444: * mediante xajax y lo dibujaremos en la vista.
445: *
446: * Función php sombra($form_entrada) llamada con xajax desde el formulario
447: * id='sombra' onclick="xajax_sombra(xajax.getFormValues('sombra'))"
448: *
449: * @param type $form_entrada
450: * @return \xajaxResponse
451: */
452: function sombra($form_entrada) {
453: $respuesta = new xajaxResponse();
454: $fs = $form_entrada["fs"];
455: if (empty($fs)) {
456: $respuesta->call('alerta_no_factor_sombra()');
457: } else {
458: $_SESSION['fs'] = $fs;
459: $lista = "";
460: $lista.="<tr><td>" . $_SESSION['fs'] . "</td></tr>";
461: $respuesta->assign("listado_sombra", "innerHTML", $lista);
462: $respuesta->call('alerta_si_factor_sombra()');
463: } return $respuesta;
464: }
465:
466: /**
467: * Función borrar_sombra()
468: *
469: * Borramos la variable de sesión $_SESSION['fi'].
470: *
471: * Realizamos unset a la variable de sesión $_SESSION['fi'] y vaciamos
472: * el div html que dibuja la tabla con el Azimut(αº), Inclinación(βº) y FI.
473: * Ademas mostramos un mensaje de confirmación.
474: *
475: * Función php borrar_irradiacion() llamada con xajax desde la tabla de irradiación
476: * con onclick="xajax_borrar_irradiacion()".
477: *
478: * @return \xajaxResponse
479: */
480: function borrar_sombra() {
481: $respuesta = new xajaxResponse();
482: $_SESSION['fs'] = 0;
483: $respuesta->assign("listado_sombra", "innerHTML", "");
484: $respuesta->call('alerta_factor_sombra_borrado()');
485: return $respuesta;
486: }
487:
488: ////////////////////////////////////////////////////////////////////////////////
489: // Radiación media del lugar donde se ubica la instalación. Gdm(0).
490: ////////////////////////////////////////////////////////////////////////////////
491:
492: /**
493: * Función radiacion()
494: *
495: * Calculamos la radiación media en la provincia seleccionada.
496: *
497: * Comprueba que las variables de sesión $_SESSION['rad'] y $_SESSION['provincia']
498: * no estén vacías, y en caso de no estarlo, llamamos a las funciones que van
499: * a desarrolar el proceso, las cuales describimos en los siguientes puntos.
500: * Para la salida generamos dos estructuras de filas y columnas que devolveremos
501: * en dos cadenas string $lista y $lista2 mediante xajax y lo dibujaremos en la vista.
502: * Mostramos mensajes de confirmación en cada caso. En esta función no tenemos
503: * parámetros de entrada.
504: *
505: * Función php radiacion() llamada con xajax desde el formulario
506: * id='radiacion' onclick="xajax_radiacion()".
507: *
508: * @return \xajaxResponse
509: */
510: function radiacion() {
511: $respuesta = new xajaxResponse();
512: if (empty($_SESSION['rad']) || empty($_SESSION['provincia'])) {
513: $respuesta->call('alerta_no_radiacion()');
514: } else {
515: preparar_radiacion();
516: preparar_radiacion_media();
517: $lista = mostrar_radiacion_md_th();
518: $lista2 = mostrar_radiacion_th();
519: $respuesta->call('alerta_si_radiacion()');
520: $respuesta->assign("listado_radiacion", "innerHTML", $lista);
521: $respuesta->assign("listado_radiacion_resumen", "innerHTML", $lista2);
522: } return $respuesta;
523: }
524:
525: /**
526: * Función preparar_radiacion()
527: *
528: * Calculamos la radiación mensual de la provincia seleccionada.
529: *
530: * Creamos un nuevo array $rad_prov que existirá unicamente en la función. Con un
531: * foreach recorremos el array de sesión $_SESSION['rad'] con todas las provincias
532: * hasta que se cumpla la igualdad de provincias con la variable de sesión
533: * $_SESSION['provincia']. Una vez cumplida asignamos mediante los metodos Get
534: * la radiación mensual al nuevo array $rad_prov. Finalmente creamos un nuevo
535: * array de sesión $_SESSION['rad_prov'] con el contenido de $rad_prov.
536: *
537: * Función php preparar_radiacion() es invocada directamente desde la funcion php
538: * radiacion().
539: */
540: function preparar_radiacion() {
541: $rad_prov = Array();
542: foreach ($_SESSION['rad'] as $r) {
543: if ($r->getProvincia() == $_SESSION['provincia']) {
544: $rad_prov[0] = $r->getEnero();
545: $rad_prov[1] = $r->getFebrero();
546: $rad_prov[2] = $r->getMarzo();
547: $rad_prov[3] = $r->getAbril();
548: $rad_prov[4] = $r->getMayo();
549: $rad_prov[5] = $r->getJunio();
550: $rad_prov[6] = $r->getJulio();
551: $rad_prov[7] = $r->getAgosto();
552: $rad_prov[8] = $r->getSeptiembre();
553: $rad_prov[9] = $r->getOctubre();
554: $rad_prov[10] = $r->getNoviembre();
555: $rad_prov[11] = $r->getDiciembre();
556: $_SESSION['rad_prov'] = $rad_prov;
557: }
558: }
559: }
560:
561: /**
562: * Función preparar_radiacion_media()
563: *
564: * Calculamos la radiación media mensual de la provincia seleccionada.
565: *
566: * Declaramos la variable auxiliar temporal $aux con valor cero. Con un ciclo
567: * for desde cero hasta 11 recorremos el array de sesión $_SESSION['rad_prov']
568: * con todas la radiacion mensual de la provincia seleccionada y acumulamos la
569: * suma de la radiación mensual en la variable $aux. Calculamos la media dividiendo
570: * el valor de la variable $aux entre 12 y el valor resultante lo almacenamos en
571: * la variable $rad_media. A continuación obtenemos $gdm_0 dividiendo el valor
572: * de la nueva variable $rad_media entre 3600. Finalmente asignamos los valores
573: * de $rad_media y $gdm_0 a las variables de sesión $_SESSION['rad_media'] y
574: * $_SESSION['gdm_0'].
575: *
576: * Función php preparar_radiacion_media() es invocada directamente desde la
577: * funcion php radiacion().
578: */
579: function preparar_radiacion_media() {
580: $aux = 0;
581: for ($i=0;$i<=11;$i++) {
582: $aux += $_SESSION['rad_prov'][$i];
583: }
584: $rad_media = $aux/12;
585: $gdm_0 = $rad_media/3600;
586: $_SESSION['rad_media'] = $rad_media;
587: $_SESSION['gdm_0'] = $gdm_0;
588: }
589:
590: /**
591: * Función mostrar_radiacion_th()
592: *
593: * Generamos la vista en una tabla en radiación.
594: *
595: * Para la salida generamos una estructura de filas y columnas que devolveremos
596: * en una cadena string $lista mediante return a la funcion que la invoca.
597: *
598: * Función php mostrar_radiacion_th() es invocada directamente desde la
599: * funcion php radiacion().
600: *
601: * @return string
602: */
603: function mostrar_radiacion_th() {
604: $lista = "";
605: $lista.="<tr><td>" . number_format($_SESSION['rad_media'], 5, '.', '') . "</td>";
606: $lista.="<td>" . number_format($_SESSION['gdm_0'], 5, '.', '') . "</td></tr>";
607: return $lista;
608: }
609:
610: /**
611: * Función mostrar_radiacion_md_th()
612: *
613: * Generamos la vista en una tabla modal en radiación.
614: *
615: * Para la salida generamos una estructura de filas y columnas que devolveremos
616: * en una cadena string $lista2 mediante return a la funcion que la invoca.
617: *
618: * Función php mostrar_radiacion_md_th() es invocada directamente desde la
619: * funcion php radiacion().
620: *
621: * @return string
622: */
623: function mostrar_radiacion_md_th() {
624: $lista2 = "";
625: $lista2.="<tr><td>" . $_SESSION['rad_prov'][0] . "</td>";
626: $lista2.="<td>" . $_SESSION['rad_prov'][1] . "</td>";
627: $lista2.="<td>" . $_SESSION['rad_prov'][2] . "</td>";
628: $lista2.="<td>" . $_SESSION['rad_prov'][3] . "</td>";
629: $lista2.="<td>" . $_SESSION['rad_prov'][4] . "</td>";
630: $lista2.="<td>" . $_SESSION['rad_prov'][5] . "</td>";
631: $lista2.="<td>" . $_SESSION['rad_prov'][6] . "</td>";
632: $lista2.="<td>" . $_SESSION['rad_prov'][7] . "</td>";
633: $lista2.="<td>" . $_SESSION['rad_prov'][8] . "</td>";
634: $lista2.="<td>" . $_SESSION['rad_prov'][9] . "</td>";
635: $lista2.="<td>" . $_SESSION['rad_prov'][10] . "</td>";
636: $lista2.="<td>" . $_SESSION['rad_prov'][11] . "</td></tr>";
637: return $lista2;
638: }
639:
640: /**
641: * Función borrar_radiacion()
642: *
643: * Borramos la variable de sesión $_SESSION['rad_prov'], $_SESSION['gdm_0'] y
644: * $_SESSION['rad_media'].
645: *
646: * Realizamos unset a las variables de sesión $_SESSION['rad_prov'],
647: * $_SESSION['gdm_0'] y $_SESSION['rad_media'] y vaciamos los elementos div que
648: * dibujan la tabla con la Radiación(kWh/(m2día)) y el Gdm(0)(kWh/día) y el div
649: * que muestra la tabla de la radiación mensual en el componente modal. Ademas
650: * mostramos un mensaje de confirmación.
651: *
652: * Función php borrar_radiacion() llamada con xajax desde la tabla de radiación
653: * con onclick="xajax_borrar_radiacion()".
654: *
655: * @return \xajaxResponse
656: */
657: function borrar_radiacion() {
658: $respuesta = new xajaxResponse();
659: unset($_SESSION['rad_prov']);
660: unset($_SESSION['gdm_0']);
661: unset($_SESSION['rad_media']);
662: $respuesta->assign("listado_radiacion", "innerHTML", "");
663: $respuesta->assign("listado_radiacion_resumen", "innerHTML", "");
664: $respuesta->call('alerta_radiacion_borrada()');
665: return $respuesta;
666: }
667:
668: ////////////////////////////////////////////////////////////////////////////////
669: // Valor medio mensual de radiación diaria sobre plano orientado α β. Gdm(α,β).
670: ////////////////////////////////////////////////////////////////////////////////
671:
672: /**
673: * Función gdm_ab()
674: *
675: * Calculamos la radiación diaria Gdm(α,β).
676: *
677: * Comprueba que las variables $gdm_0, $fs, $fi, $fk no estén vacías, y en caso
678: * de no estarlo, calculamos $gdm_ab como el producto de $gdm_0 * $fs * $fi * $fk.
679: * Asignamos a una variable de sesión $_SESSION['gdm_ab'] el valor obtenido. Para
680: * la salida generamos una estructura de filas y columnas que devolveremos en una
681: * cadena string $lista mediante xajax y lo dibujaremos en la vista.
682: * Mostramos mensajes de confirmación en cada caso. En esta función no tenemos
683: * parámetros de entrada.
684: *
685: * Función php gdm_ab() llamada con xajax desde el formulario id='form_gdm_ab'
686: * onclick="xajax_gdm_ab()".
687: *
688: * @return \xajaxResponse
689: */
690: function gdm_ab() {
691: $respuesta = new xajaxResponse();
692: $gdm_0 = $_SESSION['gdm_0'];
693: $fs = $_SESSION['fs'];
694: $fi = $_SESSION['fi'];
695: $fk = $_SESSION['fk'];
696: if (empty($gdm_0) || empty($fs) || empty($fi) || empty($fk)) {
697: $respuesta->call('alerta_no_gdm_ab()');
698: } else {
699: $gdm_ab = $gdm_0 * $fs * $fi * $fk;
700: $_SESSION['gdm_ab'] = $gdm_ab;
701: $lista = "";
702: $lista.="<tr><td>" . number_format($gdm_0, 5, '.', '') . "</td>";
703: $lista.="<td>" . $fs . "</td>";
704: $lista.="<td>" . $fi . "</td>";
705: $lista.="<td>" . $fk . "</td>";
706: $lista.="<td>" . number_format($gdm_ab, 5, '.', '') . "</td></tr>";
707: $respuesta->assign("listado_gdm_ab", "innerHTML", $lista);
708: $respuesta->call('alerta_si_gdm_ab()');
709: } return $respuesta;
710: }
711:
712: /**
713: * Función borrar_gdm_ab()
714: *
715: * Borramos la variable de sesión $_SESSION['gdm_ab'].
716: *
717: * Realizamos unset a la variable de sesión $_SESSION['gdm_ab'] y vaciamos el
718: * elemento div que dibuja la tabla con Gdm(0), FS, FI, FK y Gdm(α,β). Además
719: * mostramos un mensaje de confirmación.
720: *
721: * Función php borrar_gdm_ab() llamada con xajax desde la tabla de gdm_ab
722: * con onclick="xajax_borrar_gdm_ab()".
723: *
724: * @return \xajaxResponse
725: */
726: function borrar_gdm_ab() {
727: $respuesta = new xajaxResponse();
728: unset($_SESSION['gdm_ab']);
729: $respuesta->assign("listado_gdm_ab", "innerHTML", "");
730: $respuesta->call('alerta_gdm_ab_borrado()');
731: return $respuesta;
732: }
733:
734: ////////////////////////////////////////////////////////////////////////////////
735: // Sistemas y eficiencia instalación PR en condiciones de trabajo.
736: ////////////////////////////////////////////////////////////////////////////////
737:
738: /**
739: * Función sistema($form_entrada)
740: *
741: * Obtenemos el tipo de sistema, directo, con inversor o con inversor y batería.
742: *
743: * Comprueba que la variable $sistema con los datos del sistema no esté vacía,
744: * y en caso de no estarlo, mediante un foreach recorremos el Array $_SESSION['sis']
745: * y cuando se cumple la condicion de igualdad en el sistema elegido, guardamos
746: * en la variable de sesion $_SESSION['pr'] el factor Pr asociado al sistema.
747: * Para la salida generamos una estructura de filas y columnas que devolveremos
748: * en una cadena string $lista mediante xajax y lo dibujaremos en la vista.
749: * Finalmente mostramos un mensaje.
750: *
751: * Función php sistema($form_entrada) llamada con xajax desde el formulario
752: * id='form_sistema' onclick="xajax_sistema(xajax.getFormValues('form_sistema'))".
753: *
754: *
755: * @param type $form_entrada
756: * @return \xajaxResponse
757: */
758: function sistema($form_entrada) {
759: $respuesta = new xajaxResponse();
760: $sistema = $form_entrada["sistema_eficiencia"];
761: if (empty($sistema)) {
762: $respuesta->call('alerta_no_sistema()');
763: } else {
764: foreach ($_SESSION['sis'] as $s) {
765: if ($s->getSistema() == $sistema) {
766: $_SESSION['pr'] = $s->getPr();
767: $lista = "";
768: $lista.="<tr><td>" . $s->getSistema() . "</td>";
769: $lista.="<td>" . $s->getPr() . "</td></tr>";
770: $respuesta->assign("listado_sistema", "innerHTML", $lista);
771: $respuesta->call('alerta_si_sistema()');
772: }
773: }
774: } return $respuesta;
775: }
776:
777: /**
778: * Función borrar_sistema()
779: *
780: * Borramos la variable de sesión $_SESSION['pr'].
781: *
782: * Realizamos unset a la variable de sesión $_SESSION['pr'] y vaciamos el
783: * elemento div que dibuja la tabla con el Tipo de Sistema y el Factor PR. Además
784: * mostramos un mensaje de confirmación.
785: *
786: * Función php borrar_sistema() llamada con xajax desde la tabla de sistema
787: * con onclick="xajax_borrar_sistema()".
788: *
789: * @return \xajaxResponse
790: */
791: function borrar_sistema() {
792: $respuesta = new xajaxResponse();
793: unset($_SESSION['pr']);
794: $respuesta->assign("listado_sistema", "innerHTML", "");
795: $respuesta->call('alerta_sistema_borrado()');
796: return $respuesta;
797: }
798:
799: ////////////////////////////////////////////////////////////////////////////////
800: // Potencia mínima y máxima a instalar. Pmp,min y Pmp,max.
801: ////////////////////////////////////////////////////////////////////////////////
802:
803: /**
804: * Función pmp_min_pmp_max()
805: *
806: * Calculamos la Pmp,min y Pmp,max.
807: *
808: * Comprueba que las variables $ed, $gcem, $gdm_ab, $pr no estén vacías, y en caso
809: * de no estarlo, calculamos $pmp_min como el producto de $ed y $gcem dividido entre
810: * el producto de $gdm_ab y $pr. Una vez calculado asignamos este valor de $pmp_min
811: * a la variable de sesión $_SESSION['pmp_min']. Una vez obtenida $pmp_min, vamos
812: * a calcular $pmp_max como producto de $pmp_min por 1.2, y también la signamos
813: * a una variable de sesión, $_SESSION['pmp_max']. Para la salida generamos una
814: * estructura de filas y columnas que devolveremos en una cadena string $lista
815: * mediante xajax y lo dibujaremos en la vista. Mostramos mensajes de confirmación
816: * en cada caso. En esta función no tenemos parámetros de entrada.
817: *
818: * Función pmp_min_pmp_max() llamada con xajax desde el formulario id='form_potencia'
819: * con onclick="xajax_pmp_min_pmp_max()".
820: *
821: * @return \xajaxResponse
822: */
823: function pmp_min_pmp_max() {
824: $respuesta = new xajaxResponse();
825: $ed = $_SESSION['energia_total'];
826: $gcem = 1;
827: $gdm_ab = $_SESSION['gdm_ab'];
828: $pr = $_SESSION['pr'];
829: if (empty($ed) || empty($gcem) || empty($gdm_ab) || empty($pr)) {
830: $respuesta->call('alerta_no_pmp_min_pmp_max()');
831: } else {
832: $_SESSION['pmp_min'] = $pmp_min = (($ed * $gcem)/($gdm_ab * $pr));
833: $_SESSION['pmp_max'] = $pmp_max = $pmp_min * 1.2;
834: $lista = "";
835: $lista.="<tr><td>" . number_format($ed, 5, '.', '') . "</td>";
836: $lista.="<td>" . number_format($pmp_min, 5, '.', '') . "</td>";
837: $lista.="<td>" . number_format($pmp_max, 5, '.', '') . "</td></tr>";
838: $respuesta->assign("pmp_min_pmp_max_th", "innerHTML", $lista);
839: $respuesta->call('alerta_si_pmp_min_pmp_max()');
840: } return $respuesta;
841: }
842:
843: /**
844: * Función borrar_pmp_min_pmp_max()
845: *
846: * Borramos las variables de sesión $_SESSION['pmp_min'] y $_SESSION['pmp_max'].
847: *
848: * Realizamos unset a las variables de sesión $_SESSION['pmp_min'] y $_SESSION['pmp_max']
849: * y vaciamos el elemento div que dibuja la tabla con Ed(kWh/día), Pmp,min(kWp) y
850: * Pmp,max(kWp). Además mostramos un mensaje de confirmación.
851: *
852: * Función php borrar_pmp_min_pmp_max() llamada con xajax desde la tabla de
853: * Pmp,min y Pmp,max onclick="xajax_borrar_pmp_min_pmp_max()".
854: *
855: * @return \xajaxResponse
856: */
857: function borrar_pmp_min_pmp_max() {
858: $respuesta = new xajaxResponse();
859: unset($_SESSION['pmp_min']);
860: unset($_SESSION['pmp_max']);
861: $respuesta->assign("pmp_min_pmp_max_th", "innerHTML", "");
862: $respuesta->call('alerta_pmp_min_pmp_max_borrado()');
863: return $respuesta;
864: }
865:
866: ////////////////////////////////////////////////////////////////////////////////
867: // Datos del Módulo Solar.
868: ////////////////////////////////////////////////////////////////////////////////
869:
870: /**
871: * Función panel($form_entrada)
872: *
873: * Obtenemos el panel seleccionado con el menú desplegable, y verificamos si es
874: * compatible y el numero de paneles necesarios en caso de serlo.
875: *
876: * Comprueba que las variable de entrada $panel no esté vacía, y en caso de no
877: * estarlo, mediante un foreach recorremos el Array $_SESSION['pan'] y cuando se
878: * cumple la condicion de igualdad en el panel seleccionado, guardamos en la
879: * variable de sesion $_SESSION['panel'] el modelo del panel. Para la salida
880: * generamos dos estructuras de filas y columnas que devolveremos en dos cadenas
881: * string $lista y $lista2 mediante xajax y lo dibujaremos en la vista. Mostramos
882: * mensajes de confirmación en cada caso.
883: *
884: * Función php panel($form_entrada) llamada con xajax desde el formulario
885: * id='panel_solar' onclick="xajax_panel(xajax.getFormValues('panel_solar'))".
886: *
887: * @param type $form_entrada
888: * @return \xajaxResponse
889: */
890: function panel($form_entrada) {
891: $respuesta = new xajaxResponse();
892: $panel = $form_entrada["panel"];
893: if (empty($panel)) {
894: $respuesta->call('alerta_no_panel()');
895: } else {
896: foreach ($_SESSION['pan'] as $p) {
897: if ($p->getModelo() == $panel) {
898: $_SESSION['panel'] = $p->getModelo();
899: $lista = mostrar_panel_th($p);
900: $lista2 = mostrar_panel_md_th($p);
901: $respuesta->assign("listado_panel", "innerHTML", $lista);
902: $respuesta->assign("listado_panel_modal", "innerHTML", $lista2);
903: $respuesta->assign("mod_pan_div_md", "innerHTML", $p->getModelo());
904: $respuesta->call('alerta_si_panel()');
905: }
906: }
907: } return $respuesta;
908: }
909:
910: /**
911: * Función preparar_panel($p)
912: *
913: * Calculamos el número de modulos solares compatibles. En caso de no ser
914: * compatible el modulo solar elegido, no se obtiene el cálculo.
915: *
916: * Mediante el método ceil() redondeamos el resultado por exceso a un número entero
917: * en funcion de la pmp_min de la instalación y la Pmax del panel. El número de
918: * paneles multiplicado por su Pmax debe ser inferior a la pmp_max. En caso de
919: * cumplirse se retorna el numero de paneles en una variable String $lista y se
920: * asigna el número de paneles a una variable de sesión $_SESSION['paneles']. En
921: * caso de no cumplirse se retorna el mensaje de "Panel Incompatible" en una
922: * variable String $lista.
923: *
924: * Función php preparar_panel($p) es invocada directamente desde la
925: * funcion php mostrar_panel_th($p).
926: *
927: * @param type $p
928: * @return string
929: */
930: function preparar_panel($p) {
931: $num_pan_prov = $_SESSION['pmp_min'] / ($p->getPmax()/1000);
932: $paneles = ceil($num_pan_prov);
933: $energia_paneles = $paneles * ($p->getPmax()/1000);
934: if ($energia_paneles < $_SESSION['pmp_max']) {
935: $lista ="";
936: $lista.="<td>Nº Módulos: " . $paneles . "</td></tr>";
937: $_SESSION['paneles'] = $paneles;
938: } else {
939: $lista ="";
940: $lista.="<td>Panel Incompatible</td></tr>";
941: } return $lista;
942: }
943:
944: /**
945: * Función mostrar_panel_th($p)
946: *
947: * Generamos la vista en una tabla en Módulo Solar.
948: *
949: * Para la salida generamos una estructura de filas y columnas que devolveremos
950: * en una cadena string $lista mediante return a la funcion que la invoca. Se
951: * invoca a la función preparar_panel($p) mostrando su resultado en el string.
952: *
953: * Función php mostrar_panel_th($p) es invocada directamente desde la
954: * funcion php panel($form_entrada).
955: *
956: * @param type $p
957: * @return type
958: */
959: function mostrar_panel_th($p) {
960: $lista = "";
961: $lista.="<tr><td>" . $p->getModelo() . "</td>";
962: $lista.="<td>" . $p->getPmax() . "</td>";
963: $lista.= preparar_panel($p);
964: return $lista;
965: }
966:
967: /**
968: * Función mostrar_panel_md_th($p)
969: *
970: * Generamos la vista en una tabla modal con los datos del módulo seleccionado.
971: *
972: * Para la salida generamos una estructura de filas y columnas que devolveremos
973: * en una cadena string $lista2 mediante return a la funcion que la invoca.
974: *
975: * Función php mostrar_panel_md_th($p) es invocada directamente desde la
976: * funcion php panel($form_entrada).
977: *
978: * @param type $p
979: * @return string
980: */
981: function mostrar_panel_md_th($p) {
982: $lista2 = "";
983: $lista2.="<tr><td>" . $p->getModelo() . "</td>";
984: $lista2.="<td>" . $p->getPmax() . "</td>";
985: $lista2.="<td>" . $p->getTolerancia() . "</td>";
986: $lista2.="<td>" . $p->getVmpp() . "</td>";
987: $lista2.="<td>" . $p->getImpp() . "</td>";
988: $lista2.="<td>" . $p->getConfiguracion() . "</td>";
989: $lista2.="<td>" . $p->getPeso() . "</td>";
990: $lista2.="<td>" . $p->getIcc() . "</td>";
991: $lista2.="<td>" . $p->getVoc() . "</td></tr>";
992: return $lista2;
993: }
994:
995: /**
996: * Función borrar_panel()
997: *
998: * Borramos las variables de sesión $_SESSION['paneles'] y $_SESSION['panel'].
999: *
1000: * Realizamos unset a las variables de sesión $_SESSION['paneles'] y $_SESSION['panel']
1001: * y vaciamos los elementos div id="listado_panel", id="mod_pan_div_md" y
1002: * id="listado_panel_modal". Además mostramos un mensaje de confirmación.
1003: *
1004: * Función php borrar_panel() llamada con xajax desde la tabla de
1005: * Módulos con onclick="xajax_borrar_panel()".
1006: *
1007: * @return \xajaxResponse
1008: */
1009: function borrar_panel() {
1010: $respuesta = new xajaxResponse();
1011: unset($_SESSION['paneles']);
1012: unset($_SESSION['panel']);
1013: $respuesta->assign("listado_panel", "innerHTML", "");
1014: $respuesta->assign("listado_panel_modal", "innerHTML", "");
1015: $respuesta->assign("mod_pan_div_md", "innerHTML", "");
1016: $respuesta->call('alerta_panel_borrado()');
1017: return $respuesta;
1018: }
1019:
1020: ////////////////////////////////////////////////////////////////////////////////
1021: // Resumen del Cálculo de la Instalación.
1022: ////////////////////////////////////////////////////////////////////////////////
1023:
1024: /**
1025: * Función resumen()
1026: *
1027: * Obtenemos el resumen del cálculo de la instalación. Datos Significativos.
1028: *
1029: * Comprueba que las variables $usu, $ed, $prov, $pmp_min, $pmp_max, $panel, $paneles
1030: * no estén vacías, y en caso de no estarlo, generamos una estructura de filas y
1031: * columnas que devolveremos en una cadena string $lista mediante xajax y lo
1032: * dibujaremos en la vista. Mostramos mensajes de confirmación en cada caso.
1033: * En esta función no tenemos parámetros de entrada.
1034: *
1035: * Función resumen() llamada con xajax desde la tabla resumen del cálculo con
1036: * onclick="xajax_resumen()".
1037: *
1038: * @return \xajaxResponse
1039: */
1040: function resumen() {
1041: $respuesta = new xajaxResponse();
1042: $lista = "";
1043: $usu = $_SESSION['usuario'];
1044: $ed = $_SESSION['energia_total'];
1045: $prov = $_SESSION['provincia'];
1046: $pmp_min = $_SESSION['pmp_min'];
1047: $pmp_max = $_SESSION['pmp_max'];
1048: $panel = $_SESSION['panel'];
1049: $paneles = $_SESSION['paneles'];
1050: if (empty($usu) || empty($ed) || empty($prov) || empty($pmp_min) ||
1051: empty($pmp_max) || empty($panel) || empty($paneles)) {
1052: $respuesta->call('alerta_no_resumen()');
1053: } else {
1054: $lista = mostrar_resumen_th($ed,$prov,$pmp_min,$pmp_max,$panel,$paneles);
1055: $respuesta->assign("listado_resumen", "innerHTML", $lista);
1056: $respuesta->call('alerta_si_resumen()');
1057: } return $respuesta;
1058: }
1059:
1060: /**
1061: * Función mostrar_resumen_th($ed,$prov,$pmp_min,$pmp_max,$panel,$paneles)
1062: *
1063: * Generamos la vista en una tabla con los datos del resumen.
1064: *
1065: * Para la salida generamos una estructura de filas y columnas que devolveremos
1066: * en una cadena string $lista2 mediante return a la funcion que la invoca.
1067: *
1068: * Función php mostrar_resumen_th($ed,$prov,$pmp_min,$pmp_max,$panel,$paneles)
1069: * es invocada directamente desde la funcion php resumen().
1070: *
1071: * @param type $ed
1072: * @param type $prov
1073: * @param type $pmp_min
1074: * @param type $pmp_max
1075: * @param type $panel
1076: * @param type $paneles
1077: * @return string
1078: */
1079: function mostrar_resumen_th($ed,$prov,$pmp_min,$pmp_max,$panel,$paneles) {
1080: $lista = "";
1081: $lista.="<tr><td>" . number_format($ed, 5, '.', '') . "</td>";
1082: $lista.="<td>" . $prov . "</td>";
1083: $lista.="<td>" . number_format($pmp_min, 5, '.', '') . "</td>";
1084: $lista.="<td>" . number_format($pmp_max, 5, '.', '') . "</td>";
1085: $lista.="<td>" . $panel . "</td>";
1086: $lista.="<td>" . $paneles . "</td></tr>";
1087: return $lista;
1088: }
1089:
1090: /**
1091: * Función borrar_resumen()
1092: *
1093: * Borramos las variables de sesión $_SESSION['energia_total'], $_SESSION['provincia'],
1094: * $_SESSION['pmp_min'], $_SESSION['pmp_max'], $_SESSION['panel'] y $_SESSION['paneles'].
1095: *
1096: * Realizamos unset a las variables de sesión $_SESSION['energia_total'],
1097: * $_SESSION['provincia'], $_SESSION['pmp_min'], $_SESSION['pmp_max'],
1098: * $_SESSION['panel'] y $_SESSION['paneles'] y vaciamos el elemento con id
1099: * id="listado_resumen". Además mostramos un mensaje de confirmación.
1100: *
1101: * Función php borrar_resumen() llamada con xajax desde la tabla resumen del cálculo
1102: * con onclick="xajax_borrar_resumen()".
1103: *
1104: * @return \xajaxResponse
1105: */
1106: function borrar_resumen() {
1107: $respuesta = new xajaxResponse();
1108: unset($_SESSION['energia_total']);
1109: unset($_SESSION['provincia']);
1110: unset($_SESSION['pmp_min']);
1111: unset($_SESSION['pmp_max']);
1112: unset($_SESSION['panel']);
1113: unset($_SESSION['paneles']);
1114: $respuesta->assign("listado_resumen", "innerHTML", "");
1115: $respuesta->call('alerta_resumen_borrado()');
1116: return $respuesta;
1117: }
1118:
1119: /**
1120: * Función grabar_resumen()
1121: *
1122: * Grabamos en el SQL los Datos Significativos del resumen del cálculo
1123: * de la instalación.
1124: *
1125: * Comprueba que las variables $usu, $ed, $prov, $pmp_min, $pmp_max, $panel, $paneles
1126: * no estén vacías, y en caso de no estarlo, realizamos una comprobación con la
1127: * base de datos, invocando un método de la clase Dao:
1128: * Dao::verificaResumen($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles)
1129: * Si la respuesta de este método es true, se valida la condición del if y nos
1130: * muestra un mensaje advirtiéndonos que el registro ya existe en la base de datos.
1131: * Si la respuesta es false, pasamos al else e invocamos el metodo de la clase Dao:
1132: * Dao::grabarDatos($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles)
1133: * Grabando el registro en la base de datos.
1134: * Mostramos mensajes de confirmación en cada caso. En esta función no tenemos
1135: * parámetros de entrada.
1136: *
1137: * Función grabar_resumen() llamada con xajax desde la tabla resumen del cálculo
1138: * con onclick="xajax_grabar_resumen()".
1139: *
1140: *
1141: * @return \xajaxResponse
1142: */
1143: function grabar_resumen() {
1144: $respuesta = new xajaxResponse();
1145: $usu = $_SESSION['usuario'];
1146: $ed = number_format($_SESSION['energia_total'], 5, '.', '');
1147: $prov = $_SESSION['provincia'];
1148: $pmp_min = number_format($_SESSION['pmp_min'], 5, '.', '');
1149: $pmp_max = number_format($_SESSION['pmp_max'], 5, '.', '');
1150: $panel = $_SESSION['panel'];
1151: $paneles = $_SESSION['paneles'];
1152: if (empty($usu) || empty($ed) || empty($prov) || empty($pmp_min) ||
1153: empty($pmp_max) || empty($panel) || empty($paneles)) {
1154: $respuesta->call('alerta_no_grabar_resumen()');
1155: } else {
1156: if (Dao::verificaResumen($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles)) {
1157: $respuesta->call('alerta_no_grabar_resumen_existe()');
1158: } else {
1159: Dao::grabarDatos($usu,$ed,$prov,$pmp_min,$pmp_max,$panel,$paneles);
1160: $respuesta->call('alerta_si_grabar_resumen()');
1161: }
1162: } return $respuesta;
1163: }
1164:
1165: ////////////////////////////////////////////////////////////////////////////////
1166: // Historial de Cálculos.
1167: ////////////////////////////////////////////////////////////////////////////////
1168:
1169: /**
1170: * Función historial()
1171: *
1172: * Obtenemos en una tabla todos los cálculos realizados por el usuario.
1173: *
1174: * Declaramos la variable $his y le asignamos la respuesta de la invocación del
1175: * método de la clase Dao:
1176: * Dao::obtieneHistorial();
1177: * Comprueba que la variable $his no esté vacía, y en caso de no estarlo, mediante
1178: * un foreach recorremos el Array $his y cuando se cumple la condicion de igualdad
1179: * en el usuario activo en la sesión, generamos una estructuras de filas y columnas
1180: * que devolveremos en una cadena string $lista mediante xajax y lo dibujaremos
1181: * en la vista. En la tabla se mostrarán las variables $ed, $prov, $pmp_min, $pmp_max,
1182: * $panel y $paneles, pero no el usuario.
1183: * Mostramos mensajes de confirmación en cada caso.
1184: *
1185: * Función historial() llamada con xajax desde la tabla historial de cálculos
1186: * con onclick="xajax_historial()".
1187: *
1188: * @return \xajaxResponse
1189: */
1190: function historial() {
1191: $respuesta = new xajaxResponse();
1192: $lista = "";
1193: $his = Dao::obtieneHistorial();
1194: if (empty($his)) {
1195: $respuesta->call('alerta_no_historial()');
1196: } else { foreach ($his as $h) {
1197: if ($h->getUsu() == $_SESSION['usuario']) {
1198: $lista.="<tr><td>" . $h->getEd() . "</td>";
1199: $lista.="<td>" . $h->getProv() . "</td>";
1200: $lista.="<td>" . $h->getPmp_min() . "</td>";
1201: $lista.="<td>" . $h->getPmp_max() . "</td>";
1202: $lista.="<td>" . $h->getPanel() . "</td>";
1203: $lista.="<td>" . $h->getPaneles() . "</td></tr>";
1204: }
1205: }
1206: $respuesta->assign("listado_historial", "innerHTML", $lista);
1207: $respuesta->call('alerta_si_historial()');
1208: } return $respuesta;
1209: }
1210:
1211: /**
1212: * Función limpiar_historial()
1213: *
1214: * Borramos la tabla del Resumen de Cálculos.
1215: *
1216: * Vaciamos el elemento id="listado_historial". Además mostramos un mensaje de
1217: * confirmación.
1218: *
1219: * Función php limpiar_historial() llamada con xajax desde la tabla historial del
1220: * cálculo con onclick="xajax_limpiar_historial()".
1221: *
1222: * @return \xajaxResponse
1223: */
1224: function limpiar_historial() {
1225: $respuesta = new xajaxResponse();
1226: $respuesta->assign("listado_historial", "innerHTML", "");
1227: $respuesta->call('alerta_historial_borrado()');
1228: return $respuesta;
1229: }
1230: ?>