El visor de eventos

El visor de eventos es una herramienta muy útil en sistemas Windows, de Microsoft. Se trata nada más ni nada menos que de un complemento del MMC (Microsoft Management Console), un conjunto de herramientas creadas por Microsoft para gestionar tanto el hardware, como el software o características de red de nuestros sistemas; el visor de eventos se trata de un complemento de dicha herramienta.

Podemos lanzar el visor de eventos desde la consola, o buscarlo manualmente con las teclas Windows+C. Podemos usar también el famoso atajo de Windows+R y escribir eventvwr (abreviación de event viewer, o visor de eventos). Este último es el comando por excelencia para invocar dicha herramienta, que podemos utilizarla también desde la consola MSDOS:

Cuando se nos abra el visor de eventos accederemos a una ventana como la siguiente:

En la parte izquierda, aparte de las típicas pestañitas que salen siempre en esta clase de aplicaciones, podemos ver como carpetas (vistas personalizadas, registros de Windows, registros de aplicaciones y servicios y suscripciones). Ignorando lo que puedan hacer cada una de ellas, vamos a la parte derecha de la imagen, donde tenemos los distintos tipos de eventos de nuestro sistema, además de otra información que de momento no hace falta entender.

La utilidad que tiene el visor de eventos, es que al tener todo lo que sucede en nuestro sistema registrado podemos hacer filtros y analizar mejor lo que ha ocurrido. Por ejemplo, pondré uno de los casos con los que me he encontrado: el servicio MySQL no puede iniciarse y me salta en pantalla una ventana de error. Bueno, ¿qué opciones tenemos para saber qué ha pasado exactamente? Pues para eso tenemos el visor de eventos, donde podemos ver claramente por qué el MySQL ha fallado y no arranca.

Muy bien, hasta ahí la idea básica, pero para filtrar los posibles eventos y errores que tenemos en el sistema lo ideal es crear "carpetas", o vistas personalizadas, donde tengamos registrado cada uno de estos eventos. Crear vistas personalizadas es muy sencillo, simplemente haciendo click derecho en el iconito del visor de eventos, situado sobre las carpetas, y en crear vista personalizada. Al hacerlo nos saldrá la siguiente ventana:

Lo primero que llama la atención son las dos pestañas que salen ahí: Filtro y XML. De momento solo vamos a centrarnos en la primera, y ya explicaré qué se puede hacer luego con el XML. Así pues, la primera opción que nos sale sirve para elegir el momento exacto en el que sucedieron los eventos, y tal cual está tomará todos los eventos desde que se instaló el sistema operativo. En el nivel de evento podemos elegir entre Crítico, Advertencias, Detallado, Errores e Información, en este caso de prueba vamos a elegir Errores. La siguiente opción nos pide los tipos de registros de los que queremos sacar los errores, y tenemos entre registros de Windows y registros de aplicaciones y servicios: desde el segundo podemos auditar los errores de herramientas y aplicaciones propias del sistema, como PowerShell, AppLocker o Internet Explorer; mientras que en el primero tenemos acceso a la información de forma más generalizada, pues podemos seleccionar entre aplicaciones (todas las del sistema, hayan venido o no con éste), instalación, seguridad, etc. Para esta pequeña entrada, vamos a elegir Aplicación.

En cuanto hayamos elegido los eventos que queremos filtrar se nos dará la posibilidad de elegir unos IDs, ¿y qué significan estos números? Pues los nombres, por así decirlo, de estos eventos. Cada evento tiene un ID concreto, y si nos interesa uno particular podemos indicarlo aquí para crear una vista solamente para esa aplicación. Pero en este caso lo dejaremos vacío, haciendo referencia a todos los eventos de aplicaciones que causen algún error. Y si vamos más lejos, podemos incluso seleccionar usuarios o equipos permitidos para ver dicha vista (hay que recordar que el administrador o root tiene derecho a todo). Así pues, dejando los últimos espacios en blanco, creamos la vista. Podremos incluso ponerle un nombr, que en mi caso será Vista del Blog. Nos daremos cuenta de que se ha creado porque aparecerá en la lista de vistas personalizadas:

Ahora, al seleccionar esta vista, tendremos en el lado izquierdo un listado de todos los errores que se hayan provocado a causa de alguna aplicación:

Y nos indica también, que es lo más importante, por qué ha fallado. En el ejemplo, el servicio de MySQL no puede iniciarse porque el puerto que utiliza la aplicación (el 3306) ya está siendo utilizado por otra, y por lo tanto al intentar iniciar, dice que no puede y da error. Para remediarlo, bueno, es otra historia totalmente distinta y ajena al visor de eventos (lo ideal sería cerrar la aplicación que está utilizando ese puerto, para poder arrancar el MySQL).

Claro, hasta aquí está todo muy bien, podemos crear vistas personalizadas de aplicaciones, instalaciones, o cualquier cosa del sistema para analizar cómo se comporta. Como podéis ver en mi penúltima imagen, yo tengo vistas mías, personales, para tener a mano todos los errores que hay en el sistema. Cada vez que me suceda algo, solo me basta con ir ahí y echar un ojo. Pero aparte de errores, hay más cosas, como Información, así como vistas propias del visor de eventos. Para ver estas vistas, accedemos aquí:

En registro de Windows tenemos acceso a las listas que por defecto crea el sistema, en la que está seleccionada (aplicación) podemos ver, por ejemplo, lo siguiente:

Información acerca de las aplicaciones. Habrá registros que nos puedan interesar y registros que no, todo depende. Y como último detalle, si hacemos doble click en las vistas personalizadas podemos exportarlas y crear ficheros con extensión XML de ellas, ya sea para llevárnosla a otros equipos, a un pendrive, o lo que sea.

El visor de eventos tiene más utilidades que podemos combinar con por ejemplo el monitor de rendimiento, de forma que cuando la CPU se recaliente ya sea por alguna aplicación que le está dando caña, nos lo notifique también y lo deje registrado. Pero es una herramienta bastante útil cuando hay problemas en el equipo, espero que le deis un buen uso. Un saludito.

Quitando websites basura del navegador

Son muchas las veces, sobre todo para los usuarios de sistemas de Microsoft (aka Windows), donde algún virus se nos cuela y nos hace la vida imposible modificando la página web que nos sale por defecto en el navegador. Para remediar esto, lo que hace la mayoría de la gente que no tiene mucha idea es: o bien reinstalar el navegador o utilizar otro.

No obstante voy a explicar una nueva forma (de nueva no tiene mucho, pero para los usuarios de a pie muy posiblemente sí), que considero personalmente sencilla si se siguen los pasos que voy a dar. En este caso tocamos directamente el registro y modificamos la página web que sale por defecto. El registro del sistema es como una base de datos gigante donde se almacena absolutamente todo (tanto acerca del usuario, como de las aplicaciones, como del fondo de pantalla del Escritorio), es por así decirlo el núcleo del sistema operativo, pues la mayoría de los virus lo que se dedican es a contaminar el registro con basura, provocando estragos en el equipo. Y esto es lo que vamos a intentar solventar para el caso de los navegadores.

Esta técnica funciona para sistemas operativos que cuenten con PowerShell, es decir, de Windows 7 en adelante (tengo entendido también que XP lo soporta, pero no tengo ningún XP a mano para comprobarlo y en caso de no traerlo, habría que instalarlo), y nos ayudará a eliminar estos virus en caso de que, aun reiniciando, desinstalando o modificando las configuraciones del navegador, la web que sale por defecto siga ahí. Al nosotros editar el registro manualmente, forzamos a que se cambie esa web basura que solo busca visitas y lo único que ofrece es spam, aunque también nos puede ayudar a comprender mejor la estructura que tiene un navegador para ir o no a una página web (estructura que luego podemos modificar con un script, o gráficamente con las opciones que trae).

Así pues, abrimos el editor ISE de PowerShell de nuestro sistema operativo, para ello presionamos la tecla Windows+C y buscamos, como es evidente, PowerShell ISE (y alguna aplicación que se llame así debería salir por ahí). Es imprescindible hacer click derecho sobre ella para ejecutarla con permisos de administración (y en caso de no poder usar estos permisos, póngase en contacto con el propietario del equipo en cuestión o el administrador de sistemas correspondiente (?)). Antes de continuar con esto, recomendaría a los lectores que no tengan mucha idea que se pasasen por esta entrada de mi blog, donde explico los conceptos de árboles y cómo movernos por consola internamente en nuestro sistema.

Ahora bien, una vez tengamos abierto el editor con permisos elevados tendremos que movernos a lo que se denominan como Drives, que bien son hklm(HKEY_LOCAL_MACHINE) y hkcu(HKEY_CURRENT_USER). El primero nos dará todas las propiedades del equipo, y muy posiblemente aun con estos permisos no podamos acceder a todo su contenido. Respecto al segundo, que es el que vamos a tratar, contiene toda la configuración de nuestro usuario actual, es decir, de nuestro usuario y de todas las aplicaciones y configuraciones que tengamos junto a él (porque al crear un nuevo usuario, no tenemos el mismo fondo de Escritorio, ¿verdad? Pues esto se aplica al resto de aplicaciones, valga la redundancia).

Para movernos al Drive de nuestro usuario actual, lanzamos lo siguiente desde el editor (podemos presionar Ctrl+R para que la pantallita azul se expanda, que es lo ideal para que sea más cómodo):

Nos movemos al registro de nuestro usuario actual haciendo algo tan fácil como eso. Ya no nos encontramos en el disco C, sino en el registro del sistema. Pero claro, ¿dónde podemos encontrar las configuraciones de los navegadores? Pues cada uno de ellos tiene su ruta, y podemos ver qué opciones tenemos con el siguiente comando, para decidir a dónde movernos dentro del árbol del registro:

Ignorando lo que el comando pueda significar (no pretendo que esto sea una clase de PowerShell ni mucho menos), podemos ver que tenemos cosas como las impresoras, el panel de control, y Software; estas cosas se denominan claves del registro, y cada una tiene propiedades y más claves internas que son las que almacenan la configuración. La idea en nuestro caso es ir a la última mencionada, a software.

Y entre toda esa maraña de claves tenemos la más importante y a la que accederemos (la última), que será Microsoft. Dentro ya de Microsoft, seguimos la siguiente ruta para alcanzar la configuración del navegador:

Si volvemos a lanzar un Get-ChildItem para ver las claves del navegador IE nos daremos cuenta de que hay una llamada Main, esta es la que contiene la página web por defecto (pero no la contiene como una clave, sino como una propiedad). Podemos ver las propiedades del IE de la siguiente forma:

No es muy difícil identificar ahora qué propiedades han sido infectadas por el virus o no. En mi caso, las propiedades son las que tienen el valor más largo (los enlaces gigantes esos). Para remediarlo, simplemente las editamos y ponemos la página web que más nos guste:

Si ahora abrimos el Internet Explorer tal cual, nos podrá seguir saliendo la página de spam aunque podamos ver en la configuración que se nos ha asignado la de google, ¿y por qué pasa esto? Porque el registro no se ha actualizado. Debemos reiniciar el equipo para poder ver los cambios.

Tenemos también otra opción para editar el registro gráficamente, para ello presionamos Windows+R y escribimos regedit. De esta forma estaremos abriendo el registro de forma gráfica. Si una vez dentro queremos buscar dónde se encuentra la clave del registro que ha sido infectada por el virus, simplemente vamos a la pestaña Edición y en Buscar insertamos el nombre de la página web (por ejemplo www.webBasura.com). El registro encontrará alguna clave que tenga alguna propiedad con este valor, y efectivamente nos indicará la ruta completa. Gracias a esto bien podemos editarlo de forma gráfica o por comandos, con el editor ISE. Yo lo haré con comandos, que me resulta más amigable después de todo, no me vaya a equivocar pinchando donde no debo:

Esa sería la ruta de forma gráfica, ¿y por línea de comandos? Pues así:

Localizada la propiedad a eliminar, modificamos su valor por el que debería tener por defecto:

De esta forma ya tenemos, por ejemplo la clave del registro del Chrome editada a nuestra manera. La idea de esto es buscar constantemente por la web basura e ir modificando todas las claves del registro que la tengan, tanto de HKEY_LOCAL_MACHINE como de HKEY_CURRENT_USER.

Pero todo esto ha funcionado en principio para Internet Explorer, un navegador que casi nadie usa hoy en día, o el Chrome. ¿Qué pasa con otros navegadores como Mozilla Firefox? Pues bien podemos buscar sus rutas (cosa más complicada, pues están en otra ubicación totalmente distinta y es cuestión de buscar por el registro, y el Google Chrome carece de bastantes herramientas que no tiene el Mozilla o el IE para solventar estas cosas), o acceder a la configuración del propio navegador:

Todo esto parte de la opción de Configuración comentada al principio. Podemos ir a Extensiones y borrar aquellas que consideremos que son basura o se nos han colado, también podemos entrar a Establecer un conjunto de páginas para indicar qué páginas queremos que se nos abran cuando iniciemos el navegador. Es importante tener en cuenta, si recordamos las claves del registro que tenía el Internet Explorer, que el navegador fue infectado en distintas propiedades (como Search Page, Start Page, etc). Todo esto lo debemos modificar, por lo que cambiando las páginas de inicio no servirá de nada (cosa que me he encontrado por ahí). Tenemos que editar también los motores de búsqueda:

El Mozilla Firefox debería tener unas opciones similares al Chrome, por lo que no lo voy a tocar. Pero sí me gustaría aclarar antes de terminar que, si el problema de la web basura persiste, quizás es que se nos ha instalado algún malware en el equipo, y para ver si tenemos algo instalado que se denomine como la página de spam debemos entrar en el Panel de Control:

En la opción de Desinstalar un programa tendremos una lista de todos los programas del equipo, y si hay alguno que se llame "WebBasura" cuando la página de spam es "WebBasura.com", pues es suficiente con eliminar el programa del ordenador (me he visto casos así también x_D).

Otras medidas que podrían funcionar es, por ejemplo, yendo a las propiedades del navegador y buscar si la web de spam todavía persiste dentro:

O sencillamente intentando bloquear el tráfico a dicha página utilizando el fichero de texto hosts, ubicado en Windows en: C:\Windows\System32\Drivers\etc\hosts; este archivo lo deberemos editar con el bloc de notas teniendo permisos de administración, y sería suficiente con localizar la siguiente sección para añadir la última línea (donde sale www.WebBasura.com):

La dirección IPv4 127.0.0.1 se refiere a nuestro equipo, es decir, que cuando escribamos en el navegador la página www.WebBasura.com la intentará buscar en nuestro ordenador en lugar de salir a Internet, y de esta forma no se tendría acceso a la misma. Recordar que no hay que tocar nada más de este archivo (ni cabe mencionar que está prohibido eliminarlo), pues es un fichero importante del sistema y podría dar a futuros problemas si no se encuentra. En sistemas Linux (Ubuntu), suele estar ubicado en: /etc/hosts.

Para Google Chrome, además, me he dado cuenta a última hora de que se puede hacer también un pequeño copypaste en sus archivos de configuración principal, siguiendo esta ruta en nuestro Explorador de Windows (en nuestras carpetas, vamos):

%UserProfile%\AppData\Local\Google\Chrome\User Data\Default

En esa ubicación tenemos dos ficheros: Preferences y Web Data. La idea aquí es cambiarle el nombre por Preferences.old y Web Data.old.

Puede haber muchos métodos más, por supuesto, pero espero que esto al menos ayude a alguien a salir de algún apuro. Un saludito.

Aprendiendo PHP [3]

En la ultima entrada aprendimos a programar la inserción de nuevos clientes y a sacar todos los registros de nuestra tabla en la pantalla del navegador. Ahora, lo que vamos a hacer es generar un nuevo enlace que nos permita eliminar registros de nuestra base de datos, como clientes que se hayan dado de baja.

Para ello, tendremos que añadir un nuevo campo a nuestra tabla de Registros.php que contenga un enlace por cada usuario, y cuando pinchemos dicho enlace, nos borre dicho cliente y, además, nos lleve a una nueva página llamada Borrar.php donde nos volverá a mostrar todos los clientes que tenemos y nos vuelva a dar la opción de seguir eliminándolos. Y en este punto podrán surgir dudas como: ¿por qué crear una nueva página php en lugar de volver a llamarse a sí misma? Porque en el futuro haremos modificaciones sobre Registros.php, de forma que podamos realizar más operaciones sobre los clientes, y cada operación nos lleve a un nuevo php donde nos permita seguir ejecutando dicha operación.

Bueno, una vez ha quedado toda la teoría dicha, pasemos a la práctica. Lo primero es añadir el enlace en la tabla:

Simplemente añadimos el nuevo campo Eliminar a nuestra tabla y, dentro del bucle, añadimos un nuevo campo con un enlace que nos llevará al fichero BorrarRegistros.php, además, le pasará una variable llamada codigoCl cuyo contenido será el código del cliente actual en ese momento del bucle. Esto, si usamos el método GET de nuestro formulario en la web principal, lo entenderemos mejor, al ver cómo se pasan variables/parámetros de un archivo a otro. Lo ideal claro está es que todo vaya mediante el método POST.

Ahora tendremos que crear nuestra nueva página web: BorrarRegistros.php. Al igual que Registros.php, crearemos una estructura en HTML y comenzaremos con unas cuantas líneas de código en php:

Finalmente, BorrarRegistros.php terminaría quedando de la siguiente forma, donde realizamos la conexión gracias a Conectar.php, recogemos el codigoCl que le hemos pasado en el bucle de Registros.php y ejecutamos las consultas SQL para eliminar el registro cuando el código coincida y posteriormente, con el registro eliminado, nos vuelva a hacer un select. El resto de la página web sería literalmente, igual que la anterior: realizar un bucle en base a las líneas que contiene la tabla y poner un enlace al final. Además, damos la posibilidad de volver a eliminar registros.

No obstante, si lo dejamos así tal cual, en principio, no vamos a tener problemas. Pero si, por casualidades de la vida, ese cliente ha comprado algo y se encuentra como clave foránea en la tabla de compras no podremos eliminarlo, y es aquí donde ya tenemos que tener en cuenta nuestro diseño de la base de datos, por tanto, añadimos el siguiente código:

Suponiendo por supuesto que la tabla de las compras tiene la siguiente estructura:

Donde codigoPr es el código del producto vendido a un determinado cliente. Ambas columnas serán claves foráneas de las respectivas tablas, donde son claves primarias.

Hecho esto, deberíamos tener lo siguiente tras insertar un nuevo registro en la tabla de clientes:

Y si intentamos eliminar el registro número 69 (menudo numerito ha tenido que tocar xD), iremos a la siguiente pantalla:

Donde podemos seguir eliminando registros a placer y además nos da la opción de volver a la página principal para volver a insertar otro nuevo. Y con esto ya estaría la parte de la sentencia DELETE completa.

Aprendiendo PHP [2]

En la primera parte de "Aprendiendo PHP" vimos cómo creábamos la página web principal utilizando un formulario para que el usuario pudiese registrarse en nuestra base de datos. Además, aplicamos estilos en CSS y creamos un archivo PHP con variables constantes para poder conectarnos al MySQL de nuestro servidor.

En esta parte vamos a crear un archivo PHP que nos muestre todos los usuarios registrados en la base de datos una vez hayamos insertado uno nuevo, más que nada para comprobar que se ha añadido correctamente. Para esto tenemos que realizar varias consultas propias del lenguaje SQL a la base de datos, como "Insert into" o "Select * from". La idea principal es que se registre al nuevo usuario a partir del HTML principal y luego se muestren todos los registros, así que el fichero que hará esto lo denominaremos como (al menos yo): "Registros.php".

Tenemos además que añadir en el action del formulario de la página HTML nuestro fichero "Registros.php", de esta forma, al presionar el botón que registre los usuarios se envíen los datos al nuevo fichero PHP, desde donde los vamos a manipular.

Bien, una vez tengamos el html vinculado al css y al php, la idea será básicamente crear una nueva página en el fichero php, con su DOCTYPE y el resto de etiquetas fundamentales para una página web (head, body...). En mi caso, empezaré con algo así:

Como ya tengo Registros.php vinculado al CSS, no me hará falta vincularlo en Conectar.php, por lo que ahí comentaré esa línea. Y nada más empezar el archivo, se incluirá código PHP que llame al fichero Conectar.php y nos conecte nada más cargarse la web en el navegador.

Ahora, dentro del body tendremos que ir mezclando tanto PHP como HTML, de forma que el código quede como a nosotros nos interese. Lo principal será recoger los datos que se han pasado del HTML, es decir, los datos del nuevo usuario, para insertarlos en nuestra tabla de clientes.

Tenemos que darnos cuenta de que este lenguaje tiene muchas similitudes con el lenguaje C, así que si estáis acostumbrados a programar en él sabréis que el include se utiliza principalmente cargar librerías de código, los que no, no penséis en esto último. Tan solo pensad que las constantes y las consultas de ese fichero es como si la estuviésemos escribiendo en nuestro Registros.php.

Sobre la captura, declaramos cuatro variables con los datos de los clientes, todas las variables deben comenzar con el símbolo de dolar al principio. Y el método $_REQUEST nos permitirá coger, al enviar datos desde un formulario, los valores que tienen las etiquetas INPUT de dicho formulario. A esas etiquetas les hemos puesto un atributo name con un valor, ese es el valor que tenemos que indicar en el request. Si a un input le hemos puesto el atributo name "pepito", tendremos que indicar que $variable=$_REQUEST['pepito']; para que pueda recoger su valor.

Ahora, una vez tenemos los valores (podemos asegurarnos de que los tenemos usando en el formulario el método GET, de forma que se vea en el navegador lo que estamos pasando, o bien usar en el PHP una función PRINT("$nombre"); de forma que saquemos los datos de nuestras variables y ver sus respectivos valores.

En la captura, tras recoger los datos del nuevo cliente, declaramos dos variables iniciales que serán, en principio, texto. Solamente texto. Una será la consulta de insert into en nuestra base de datos (omitimos el valor del código, porque se incrementa solo a cada registro), y otra será el select que nos sacará las tuplas al navegador. Posteriormente, declaramos otras dos variables que, en ese preciso momento, ejecutarán las consultas mediante el MYSQLI_QUERY. La variable $conexion proviene de Conectar.php.

La inserción, pues, se hará correctamente, pero el problema viene al tener que sacar los datos por pantalla de todos nuestros clientes. Para esto tenemos la variable de la consulta select, pero tenemos que recorrer las filas e ir sacando los registros uno por uno. Yo optaré por hacerlo mediante una tabla, para que se asemeje todo lo posible a una base de datos:

Está claro que la primera fila de la tabla, como siempre será fija, no estará sujeta a un código PHP. Pero el resto de la tabla sí será variable, porque saldrán más o menos registros dependiendo de los que tengamos en la tabla. Por lo tanto, nada más terminar la primera fila, generamos un código PHP que nos cuente la cantidad de filas de la consulta select mediante el MYSQLI_NUM_ROWS. Y creamos, al final de la página web, un enlace para volver al HTML principal; al formulario. Podemos acompañar el enlace también con una etiqueta <hr/> para que quede más visible.

Ahora bien, tendremos que recorrer todas las filas de la sentencia select para ir sacando los datos uno por uno, ¿y cómo hacemos eso? Con un bucle que nos repita la misma operación todo el rato mientras los datos van cambiando:

Esto lo conseguimos mediante un bucle for, pero bien podemos hacerlo mediante un while. Ambas opciones son válidas. La idea es recorrer todas las filas de la consulta select, y en cada vuelta del bucle, generar una variable $cliente con todos los datos del cliente actual. Luego, con un sencillo print, sacamos los datos.

Al igual que con las consultas, tenemos que ceñirnos a los datos de la base de datos, es decir, si en la tabla cliente de la base de datos el campo código se llama "codigoCl", tenemos que indicar este nombre, porque sino no comprenderá a qué dato nos estamos refiriendo.

Y una vez hecho eso, vamos al navegador y probamos a insertar un nuevo cliente desde cero:

Y si pinchamos ahora, en Registrar... ¡Veamos qué sucede!

Vemos que primero nos sale una línea de color verde diciendo que nos hemos conectado a la base de datos. Esta línea proviene del archivo Conectar.php que tenemos en el include. Después se nos ha generado la tabla, con colorines que he implementado yo en CSS (creando las clases "tabla1" para la línea azul y la clase "tabla2" para el contenido de la tabla). Y además, nos muestra la etiqueta <hr/> junto con el enlace, que nos llevará de nuevo al formulario para ingresar otro cliente.

Si comprobamos estos cambios en nuestra base de datos directamente, tendremos lo siguiente:

Por supuesto, la tenemos ahí también. De hecho, el código PHP está sacando los datos directamente de esta tabla; si no estuviese aquí, no la mostraría en pantalla.

En caso de tener problemas (que las consultas dan muchos problemas por las comillas y las comas), podemos, tras declarar la variable $sqlX (la que realice la consulta), generar una operación "or die("<p class='false'>Error en la consulta</p>");" para que, si no se ha ejecutado la consulta correctamente, nos muestre dónde está fallando todo y que no pase desapercibido el error.

Y, ¡oh! A mí me ha generado el registro 31 porque he insertado 30 registros anteriormente en otras prácticas, y no me he molestado en reiniciar eso, que tampoco es complicado.

Hasta aquí, una nueva e interesante clase sobre PHP.

Aprendiendo PowerShell 3.0 [1]

Muy bien, aparte de lenguajes como C o PHP también me he decidido a hacer una serie de guías de iniciación a PowerShell 3.0 (la versión que me ha tocado estudiar, vamos). Y por no decir que me encanta el mundo del scripting a nivel de sistema operativo.

Empezaré haciendo uso del edito PowerShell ISE, que debería venir tanto en Windows 8/8.1 como en servidores a partir del 2008, y creo que también en Windows 7. Es un editor muy amigable que permite escribir código y probarlo al mismo tiempo, rompiendo con el concepto de "consola" o "terminal" propio de sistemas MSDOS o Linux.

Para quién no haya trabajado nunca con PowerShell, puede simplemente buscar en su sistema el editor y comprobar su versión de la siguiente forma:

El comando Get-Host nos saca en pantalla un conjunto de valores y características del PowerShell instalado en nuestro equipo. Y aquí es donde empezamos ya a explicar la dinámica que tiene el scripting en este lenguaje. Todo lo que muestran los comandos en pantalla se denomina "objetos", y cada objeto tiene sus propiedades y sus características. En nuestro caso, como Get-Host nos devuelve un objeto con las características de nuestro PowerShell instalado, le hemos dicho que mediante una "tubería" o las famosas pipes seleccionado solamente la característica o atributo "version".

Y bueno, ¿qué es eso de tuberías y pipes? Es un concepto muy utilizado en el scripting de sistemas operativos, sobre todo en Linux. Su finalidad es, básicamente, coger la salida del comando (lo que debería sacar por pantalla), en este caso Get-Host, y pasa su contenido a otro comando para que trabaje sobre esta información, de forma que podamos seleccionar solamente el atributo de la versión.

Hay otras formas de hacer tuberías donde yo creo que se entiende mucho mejor, como utilizando el comando "tee-object" que nos coge la salida del comando inicial y la redirige tanto a la pantalla como a otro comando.

Si la versión de PowerShell no es la correcta, aquí dejo una guía sobre cómo instalar la versión 3.0, que yo no he probado porque yo ya tengo dicha versión por defecto y no me ha hecho falta:

PowerShell Version 3.0

Y ahora, que está la introducción hecha, pasamos ya al scripting, que es la mejor forma de aprender. Aconsejo que no se copie y pegue solamente el código, sino que lo tecleéis todo a mano y probéis a cambiarlo y a hacer pruebas, que es la mejor forma de comprender cómo funciona el lenguaje. Durante esta serie de guías, iré haciendo ejercicios de forma que vaya aumentando la complejidad del código. Así que paciencia.

Recordar también que, en el ISE, si presionamos Ctrl+R se nos expandirá automáticamente la terminal azul hasta arriba, y si volvemos a presionar estas teclas se ajustará al tamaño anterior para permitirnos editar el código. Esto es bastante práctico a la hora de picar teclado.

¡Vamos con la primera!

1) Sumar dos números pasados por parámetro:

Bueno, la idea inicial es sencilla: pasarle dos parámetros al script y que sume sus valores. Los parámetros son variables o datos que se van pasando de un lado a otro, por ejemplo, desde un script inicial invocamos otro script pasando el valor de variables, estas variables en este script invocado se denominan parámetros. Las funciones de todo lenguaje de programación (trozos de código que hacen siempre lo mismo) también pueden recibir parámetros, y eso es lo que usaremos para filtrar los parámetros que le pasemos al archivo.

Tenemos que tener en cuenta, además, que los parámetros deben ser numéricos, porque si son letras dará error, y no estaríamos sumando, sino concatenando. También tenemos que comprobar que no haya ningún parámetro, sino estaría sumando valores vacíos.

Como costumbre, yo siempre haré programas betas donde voy comprobando paso a paso que lo que busco se va cumpliendo, no es plan de ir directamente a hacerlo todo, sino tener claras las cosas e ir poquito a poquito.

Lo primero que hago es declarar una función que me filtre la cantidad de parámetros, asegurándome de que obtengo la cantidad pasada, y los dos primeros. Vemos en la primera línea de la terminal azul cómo invocar el script y cómo pasarle los parámetros (le estamos pasando tres: número 1, número 2 y número 3). En la segunda línea invocamos el script sin parámetros, y obtenemos un error.

¿Por qué sucede esto? Bueno, he definido una función que reciba tres parámetros con el nombre que yo quiera; una regla importante a la hora de programar es que los identificadores sean claros, entendiendo por identificador el nombre de una función o variable. Aquí es muy intuitivo: $cantidad, $numero1 y $numero 2. No sería igual si fuesen: $a, $b y $c, pues resultaría caótico acordarse de qué hace cada variable (esto solamente lo hago en pruebas donde tengo pocas variables, en realidad, para ahorrar tiempo al utilizarlas).

Luego dentro de la función "sumarParametros" compruebo mediante el if ("sí" condicional) si la cantidad de parámetros no es igual a cero, si la sentencia if nos devuelve un booleano con valor true, será que , efectivamente, hemos pasado parámetros porque no es cero, pero si es false, es que es es igual que cero, y dependiendo de si devuelve una cosa u otra, saltará al else ("por el contrario", en caso de que la condición anterior no se cumpla) o ejecutará directamente lo que hay ahí.

Tenemos que darnos cuenta de que en la comprobación usamos el comparador "-ne", esto significa "not equal" (no es igual). Y en el Write-Output (alias de echo), hacemos uso del retorno de carro ("`n"), que nos hará un salto de línea.

A la hora de invocar la función utilizamos la variable de entorno $args, que contiene información relativa a los parámetros/argumentos del script. Le pasamos primero la cantidad, que será el valor de $cantidad, y luego los dos primeros parámetros. Como la variable va a contener un array (conjunto de valores, uno detrás de otro, dentro de la variable), accedemos al primer argumento usando $args[0], y al segundo mediante $args[1]. De esta forma, filtramos los parámetros que queremos utilizar.

Hasta aquí todo chachi, controlamos la cantidad y tenemos los valores de los parámetros, pero claro, necesitamos comprobar ahora que los parámetros sean números y no cualquier cosa extraña, porque tal y como está, la suma nos dará error. Si lanzamos apurados el script y se nos escapa una letra, tenemos que asegurarnos de que eso no va a petar el sistema por todos lados.

Así que, dentro de la condición, hacemos ligeros cambios para controlar el tipo de dato que nos pasan:

Una vez nos han pasado dos parámetros, comprobamos mediante un if más complejo si ambos son números, en ese caso vemos que nos dice que está todo correcto. En caso contrario, vemos que el segundo parámetro es el que da error, por lo que salta al else de esa condición.

Ya tenemos, por tanto, controlada tanto la cantidad de parámetros como sus tipos. Lo que queda es definir una variable que sume ambos números y sacarla por pantalla:

Y tenemos, finalmente, nuestra suma =)

2) Multiplicar dos números pasados por parámetro:

En este caso solo tenemos que modificar el script anterior para que multiplique, en lugar de sumar.

Aprendiendo PHP [1]

En esta entrada vamos a iniciarnos en el mundillo del PHP, aprendiendo a conectar los datos de una página web con una base de datos MySQL. En mi caso, partiré de que ya tengo creada la base de datos con sus tablas y sus claves, así como instalado el servidor web del XAMPP y todo bien configurado con host virtuales para poder acceder desde mi navegador a mis páginas HTML sin problemas.

Empezamos, pues, con la base de datos:

Podría hacerlo de forma gráfica, pero por comandos puedo acceder más rápido a la información de las tablas en caso de que algo haya salido mal. En la imagen anterior he mirado todas las bases de datos que tengo, y me decidiré a usar "Practicas", donde tengo todas las tablas. El escenario es muy sencillo: en una tienda de informática, tenemos clientes, tenemos productos, y proveedores. La tabla "compra" nos vinculará los clientes con los productos, registrando lo que han comprado. La tabla suministros, en cambio, nos dará la información acerca de los productos que nos hayan suministrado los proveedores.

Hasta aquí todo bien, pero ahora vamos a pasar al código. Lo primero que tenemos que hacer es un formulario sencillito en HTML para poder recoger datos de nuestros clientes, y estos datos posteriormente, mediante el uso de ficheros PHP, los registraremos en nuestra base de datos.

Empezamos, pues, con nuestra página web:

Primero generaremos un fichero de texto con extensión HTML, asegurándonos de que tiene la codificación "UTF-8" (para evitar que en lugar de tildes, aparezcan símbolos extraños al visualizar la página). Esto podemos hacerlo de muchas formas, pero yo prefiero esta, que es más rápida:

Reiterar que, lo importante de esto, es la codificación de caracteres. Ahora utilizaremos la herramienta de Aptana para editar y crear nuestra propia página web, que consistirá en un formulario sencillo para registrar clientes de nuestra tienda de informática:

Esta será, básicamente, la carcasa de nuestra página web. Tenemos que darnos cuenta de la etiqueta "DOCTYPE", que nos indicará qué versión de HTML utilizaremos (en este caso, supone que es HTML5), también tenemos la etiqueta "head" con la codificación, el título de la página, y un enlace a hojas de estilo CSS que no tendrá, de momento, un archivo asociado. Más adelante, cuando tengamos el formulario hecho, insertaremos en el atributo "href" un fichero de CSS para poder trabajar con colorines y tal.

Luego, debajo, tenemos la etiqueta "body" con el formulario, cuyo nombre será formulario, método post y el action ejecutará un fichero PHP cuando enviemos los datos, por ahora no tenemos creado ese fichero, así que lo dejamos vacío. Ya iremos rellenando estos atributos.

Ahora tenemos que crear el formulario en sí, y para esto, es suficiente con colocar etiquetas de "input". Pero antes, ¿qué datos necesitamos del cliente? Pues eso lo tenemos en nuestra base de datos MySQL:

La tabla de los clientes tendrá un código, que se auto incrementará con cada registro o tupla que insertemos en ella. También tendrán un nombre, unos apellidos, una dirección y un teléfono. Entonces, teniendo esto en cuenta, creamos un campo para cada columna de nuestra tabla ignorando el código del cliente, que se incrementa solo (reitero):

Creamos un título de nivel tres, y varios párrafos donde tendremos un bloque "span" y un "input" para insertar nuestros datos, además del botón. Toda esa retahíla de código, que tampoco es muy complicada, se traduce en lo siguiente:

Podemos ver el título de nivel tres en negrita, los bloques "span" antes de los "input", y los tamaños y valores que hemos asignado por defecto en las etiquetas. El evento "onclick", nos dice, que cuando pinchemos con el ratón sobre "Inserte su nombre" (o cualquier otras etiqueta "input"), su valor será nulo, es decir, la cajita de texto se vaciará. Y el atributo "name", nos servirá más adelante en el PHP para identificar cada etiqueta y recoger sus valores.

Sin embargo, ese formulario es muy soso y triste, no nos vendría mal añadirle un archivo CSS para darle vidilla:

Especificando que la cabecera de nivel tres tenga ese color en su texto, las etiquetas "input" tengan el color de su texto negro, en negrita, cursiva y en fuente Times New Roman. Y finalmente, creamos un estilo para las etiquetas "div" de nuestro documento (solo utilizaremos una): con posición relativa, margen y padding inexistentes, ancho a 500 pixels, y alto automático, el borde será de tipo groove, y tanto el fondo como el propio borde serán de color dorado. Si ahora modificamos el fichero HTML tal que:

Insertamos en el "href" del "link" nuestros estilos, y metemos dentro del formulario un contenedor "div", teniendo, finalmente, lo siguiente:

Ahora está mucho más bonito, ¿a qué sí? =)

Pues para eso tenemos el CSS. Ahora bien, el siguiente paso será entrar ya en el PHP. Lo primero que tenemos que hacer es conectar con nuestra base de datos como si fuésemos un usuario de la misma. Yo entraré con permisos de administrador, aunque siempre podemos crear usuarios en MySQL y otorgarles permisos. Pero bueno, en lo que a conectar con la base de datos "Practicas" se refiere, tendremos que crear un fichero PHP que nos haga esta función:

El concepto es sencillo, y evidentemente, esto será un fichero de pruebas que luego tendremos que editar, digamos que es una versión beta. Definimos constantes en base a los parámetros que nos pide la función "mysqli_connect", que será el lugar donde está nuestra base de datos (hay que recordar que, si tenemos un dominio y nuestro servidor es accesible desde internet, tendremos que utilizar nuestra dirección IP y tener conexión para poder conectar, en nuestro caso, al estar en local, será localhost), nuestro usuario, su clave que no la pondré aquí por razones de seguridad, y la base de datos.

Y la función para conectar, la pasamos a una variable que contendrá información. Si la conexión ha sido un éxito generaremos un fichero con una clase llamada "true" (a la que aplicaremos un estilo de background verde y color blanco), y en caso contrario sacaremos otro párrafo que nos dirá acerca del error. Esto se debe a que si la función va bien, la variable nos devolverá un booleano "true", sino, será un "false". Y los puntos del "print", nos concatenan cadenas de caracteres.

Cabe destacar, además, que un fichero PHP puede incluir etiquetas HTML, y puede ser perfectamente, una página web. Podemos, encima del código PHP, escribir un DOCTYPE, un head, y vincular nuestro fichero css al archivo PHP, que lo que hará el navegador será ejecutar este código en base a la conexión y sacar una web con un párrafo u otro. Es muy simple el concepto.

Si la conexión ha ido bien y hemos creado nuestros estilos en CSS, tendremos lo siguiente:

Podemos ver cómo la constante "base" en el print se sustituye por la base de datos que tenemos en MySQL. Y viendo lo extenso que se ha vuelto esto, hasta aquí es todo por el momento. En una futura entrada crearemos más ficheros PHP que gestionen los datos que hemos insertado en el formulario.

¡Nos vemos!