fpWeb Tutorial/es: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		Originalmente basado en el tutorial de fcl-web (en PDF) por un usuario del foro [Leledumbo](https://forum.lazarus.freepascal.org/index.php?action=profile;u=7523).
2	2
3	3		## Introducción
4	4
5	5		fpWeb es un esquema de aplicación web que viene con FPC por defecto como parte del paquete fcl-web. El esquema en sí mismo está construido encima de las características de fcl-web. El esquema está construido con mentalidad de RAD para hacer buen uso de la componentización en producir contenido dinámico. Un paquete Lazarus es provisto que pueda usar el esquema en forma de arrastrar y soltar para su administración de sesión y producción de contenido.
6	6
7	7		Este tutorial intentará cubrir la funcionalidad básica de fpWeb, así que uno puede construir una aplicación común para web con él. Note que este tutorial NO intenta enseñar ningún protocolo HTTP, HTML, CSS, JavaScript o manipulación de base de datos como los lenguajes de protocolo y cliente debieran ser los prerequisitos para cada programador de aplicaciones web y la manipulación de base de datos no difiere de la implementación de escritorio.
8	8
9	9		## Arquitectura (lea POR FAVOR)
10	10
11	11		Antes de iniciar, es necesario conocer la arquitectura y flujo de aplicación para evitar confusiones cuando ciertas cosas no funcionen o lo hagan de forma inesperada. Así que por favor pase algo de tiempo leyendo esta sección.
12	12
13	13		### Aplicación
14	14
15	15		La aplicación aquí se refiere al protocolo que su aplicación implementará. fpWeb felizmente se cambia de módulos CGI, FCGI, Apache a un servidor embebido, y más si fcl-web implementa otro en el futuro. Cada aplicación se implementa en su propia unidad, así que para cambiar de una aplicación a otra, con la excepción del módulo Apache, sólo se necesita cambiar el respectivo identificador en la cláusula uses. Para 3.0.0 en adelante son:
16	16
17	17		- fpCGI -\> CGI
18	18		- fpFCGI -\> FastCGI
19	19		- fpApache (requiere httpd también) -\> módulo Apache
20	20		- fpHttpApp -\> servidor embebido
21	21		- microhttpapp -\> servidor embebido usando la biblioteca GNU libmicrohttp.
22	22		- fphttpsys -\> soporte de sistema Windows para el protocolo HTTP.
23	23
24	24		A través de este tutorial, usaremos el servidor embebido en beneficio de simplicidad porque no tiene que tratar con configurar el servidor virtual ni enredarse con el manejo complicado de archivos y servicios. Su aplicación será una aplicación portátil binaria para web! Otra razón sería que hay más de una aplicación de servidor web y que cada una tiene una forma distinta de configurar. Sería exagerado cubrir todos mientras que su documentación hace el trabajo. El módulo Apache se implementa como una biblioteca (dinámica), mientras que otros protocolos son aplicaciones normales. Cada aplicación puede que tenga propiedades específicas (como puertos) disponibles y que sólo competen a esa aplicación. Eso es el porqué de ver los ejemplos fcl-web, pares de .lpi / .lpr para cada protocolo están puestos en sus propios directorios, sólo los módulos web se comparten.
25	25
26	26		### Módulos Web
27	27
28	28		![](/wiki-images/5/50/FpWeb-overview.png)
29	29
30	30		Las aplicaciones fpWeb constan de módulos web los que hacen la producción actual de contenido. Un módulo web puede contener acciones web que pueden dividir la funcionalidad incluso más. Por ejemplo, un módulo web auténtico puede que tenga acciones web de login y logout. Mientras que un módulo web de acerca de, puede no necesitar una acción específica y sirve sólo para un contenido. El módulo Web se integra con fpTemplate que puede usarse para producir contenido dinámico con una plantilla. Esto es bastante similar a lo que hace PHP, sólo el espacio entre la lógica y la presentación se impone en vez de lo que se sugiere. Algunos dicen que fpTemplate implementa una vista pasiva mientras que PHP por defecto implementa un patrón de diseño de vista activa.
31	31
32	32		## Instalación
33	33
34	34		El paquete fpWeb para Lazarus no se instala por defecto (pero viene con él), para activar fpWeb:
35	35
36	36		1. Abra Lazarus y escoja '''Paquetes-\>Instalar/Desinstalar Paquetes’’’
37	37		2. En el listbox disponible para la instalación, busque weblaz y presione Instala selección. Presione Guardar y reconstruir IDE y confirme con Continuar
38	38		3. Deje que el IDE se reconstruya y reincide solo. Si todo va bien, deberá ahora tener una pestaña ftweb en la paleta de componentes, como se muestra:
39	39
40	40
41	41
42	42		![](/wiki-images/5/55/Fpwebtutorial_inst.png)
43	43
44	44		## Módulos Especializados
45	45
46	46		La clase TFPWebModule (usada abajo) es un simple ejemplo del módulo fpWEB que puede usarse para toda clase de peticiones HTTP.
47	47
48	48		Sin embargo, fpWEB viene con algunos módulos especializados que tienen soporte extra para tareas especializadas:
49	49
50	50		- La clase TSimpleFileModule en la unidad fpwebfile.pp puede usarse para enviar archivos. Sólo apunte a un directorio, y él hace el resto.
51	51		- La clase TFPHTMLModule en la unidad fphtml.pp puede usarse para producir HTML.
52	52		- La clase TProxyWebModule en la unidad fpwebproxy.pp es un proxy de redirección listo para usar.
53	53		- La clase TFPWebProviderDataModule en la unidad fpwebdata.pp sirve de datos en formato JSON que puede guardar ExtJS.
54	54		- La clase TSQLDBRestModule en la unidad sqldbrestmodule.pp implementa un servidor REST completo respaldado por SQLDB. Vea más información en [[SQLDBRestBridge]].
55	55		- La clase TJSONRPCModule en la unidad webjsonrpc.pp implementa un servicio JSON-RPC.
56	56		- La clase TExtDirectModule en la unidad fpextdirect.pp implementa una variante Ext.Direct de un servicio JSON-RPC.
57	57
58	58		## Hola, Mundo!
59	59
60	60		Creemos una aplicación Web sencilla. Como se enseñó comúnmente cuando se aprendía programación, "Hola, Mundo!" será nuestra primera app.\
61	61
62	62		1\. Abra Lazarus y escoja Proyecto-\>Nuevo Proyecto luego HTTP server Application
63	63
64	64
65	65		![Create new HTTP server application](/wiki-images/5/57/Fpwebtutorial_create_app.png)\
66	66
67	67		2\. Otro diálogo deberá aparecer para servir archivos estáticos, selección de puerto y multihilo. Sólo use por defecto el puerto 8080.
68	68
69	69
70	70		``` pascal
71	71		Puede que omita servir archivos estáticos (vaya a la sección de trucos y consejos si quiere saber más).
72	72		```
73	73
74	74		![](/wiki-images/e/e6/Fpwebtutorial_port_selection.PNG)
75	75
76	76		:IMPORTANTE!:
77	77
78	78
79	79		Si escogió usar hilos en *nix, no olvide agregar cthreads como la primera unidad en la cláusula uses del archivo .lpr, de otra forma se generará un error RTE 232. Cuando se ejecuta desde una consola, un mensaje deberá aparecer:
80	80
81	81		``` pascal
82	82		Este binario no se compiló con soporte de hilos. Recompile la aplicación con un manejado de hilasen la cláusula uses del programa antes de cualquier unidad que use hilos.
83	83		```
84	84
85	85		3\. Desde Enero 14 de 2017 (o FPC 3.0.4), pueda que necesite abrir el archivo .lpr y agregar la siguiente línea en el cuerpo principal si no está puesto:
86	86
87	87
88	88		``` pascal
89	89		Application.LegacyRouting := true;
90	90		```
91	91
92	92		la razón estará explicada en el capítulo #Enrutamiento.
93	93
94	94		4\. Cualquier cosa que escoja, clique "OK" y se le presentará en el módulo de aplicación fpWeb por defecto.\
95	95		5\. Enfoque el módulo y muévase al Inspector de Objetos. Siéntase libre de renombre el módulo si así lo prefiere.\
96	96		6\. Escoja la pestaña Events y clique el botón a la derecha de la segunda columna de la fila OnRequest para crear el manejador del evento.
97	97
98	98
99	99		![Creating web module's OnRequest handler in the object inspector](/wiki-images/8/8d/Fpwebtutorial_on_request.png)\
100	100
101	101
102	102		Será dirigido al editor de código fuente con el código:
103	103
104	104		:
105	105
106	106		``` pascal
107	107		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
108	108		AResponse: TResponse; var Handled: Boolean);
109	109		begin
110	110		\|
111	111		end;
112	112		```
113	113
114	114
115	115		Escriba:
116	116
117	117		:
118	118
119	119		``` pascal
120	120		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
121	121		AResponse: TResponse; var Handled: Boolean);
122	122		begin
123	123		AResponse.Content := 'Hola, Mundo!';
124	124		Handled := true;
125	125		end;
126	126		```
127	127
128	128		7\. Luego ejecute su aplicación (o presione F9).\
129	129		8\. Abra su navegador y escriba:
130	130
131	131
132	132		<http://localhost:8080/>\
133	133
134	134		9\. Deberá ver "Hola, Mundo!'.\
135	135
136	136		En caso contrario, revise:
137	137
138	138		- El marco de trabajo hace mucho de manejo de excepciones y el depurador del IDE podrá atraparlos e interrumpe su aplicación. Está bien agregar muchas de las excepciones para la lista del olvido así que se pueda concentrar más en su flujo de aplicación. Manténgase evitando y continuando hasta que no aparezcan más diálogos y el navegador muestre el contenido.
139	139
140	140		- Handled := true es la forma que le decimos que la solicitud ha sido manejada. Si no se coloca (o se pone en false) mostrará la página de error. Por ahora, esto no afecta el flujo de peticiones, pero lo hará después. Así que déjelo así hasta que el momento en que se le de buen uso.
141	141
142	142		- otra pista: pruebe sin un cortafuegos cargado en RAM (como una aplicación, como un servicio o daemon, o ambos).
143	143
144	144		## Leyendo los datos GET & POST
145	145
146	146		Es probable que un contenido dinámico se active a partir de la entrada del usuario, tanto a través de formularios, proveyendo valores en el URL, etc. Esos datos se envían a través de la petición, la cual se representa en el método como ARequest parámetro de tipo TRequest.
147	147
148	148		### Leyendo GET
149	149
150	150		Los datos GET se proveen como ARequest.QueryFields , el cual desciende de TStrings. Resumiendo, cualquier cosa que haga con TStrings, se aplica aquí como acceder a los datos en un estilo de mapa a través de la propiedad Values.
151	151
152	152		Reusando el código anterior, reemplace el cuerpo del método con:
153	153
154	154		``` pascal
155	155		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
156	156		AResponse: TResponse; var Handled: Boolean);
157	157		var
158	158		LName: String;
159	159		begin
160	160		LName := ARequest.QueryFields.Values['Name']; // QueryFields para GET
161	161		if LName = EmptyStr then
162	162		with AResponse.Contents do begin // En el formulario <form> el
163	163		Add('<form action="%s" method="GET"', [aRequest.URI]);// solicitante
164	164		Add('<label for="name">Por favor dame tu nombre:</label>');// pondrá
165	165		Add('<input type="text" name="name" id="name" />');// name="name"
166	166		Add('<input type="submit" value="Send" />');
167	167		Add('</form>');
168	168		end
169	169		else
170	170		AResponse.Content := Format('<h1>Hola, %s!</h1>', [LName]);
171	171		Handled := true; // <— Se dio buen manejo!
172	172		end;
173	173		```
174	174
175	175		ARequest.URI es sólo una conveniencia referirse al URI actual, así que cuando cambie su módulo registrado, este código permanece igual.
176	176
177	177		Note que como en Pascal, nos referimos a los datos se hace sin importar las mayúsculas/minúsculas.
178	178
179	179		Como es una petición GET, en la dirección de la página aparece la sintaxis de lo solicitado. Ahora puede intentar la solicitud /, la cual mostrará
180	180
181	181		` Por favor dame tu nombre:`
182	182
183	183		y al final de la dirección coloque /?name=\<escriba algo aquí, p.e.: Fernando\>, lo que mostrará
184	184
185	185		` Hola, Fernando!`
186	186
187	187		### Leyendo POST
188	188
189	189		POST no difiere mucho de GET, sólo en la propiedad que accede. Si GET se acceda a través de ARequest.QueryFields, POST se accede a través de ARequest.ContentFields. El estilo de POST del código previo es:
190	190
191	191		``` pascal
192	192		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
193	193		AResponse: TResponse; var Handled: Boolean);
194	194		var
195	195		LName: String;
196	196		begin
197	197		LName := ARequest.ContentFields.Values['Name']; // ContentFields para POST
198	198		if LName = EmptyStr then
199	199		with AResponse.Contents do
200	200		begin
201	201		Add('<form action="%d" method="POST"', [ARequest.URI]);
202	202		Add('<label for="name">Por favor dame tu nombre:</label>');
203	203		Add('<input type="text" name="name" id="name" />');
204	204		Add('<input type="submit" value="Send" />');
205	205		Add('</form>');
206	206		end
207	207		else
208	208		AResponse.Content := Format('<h1>Hola, %s!</h1>', [LName]);
209	209		Handled := true;
210	210		end;
211	211		```
212	212
213	213		### Leyendo Subir Archivos
214	214
215	215		Una excepción es para los archivos de lectura multipart/form-data, p.e. los archivos. Eso está disponible en ARequest.Files como una instancia de TUploadedFiles, la cual desciende de TCollection. Lo siguiente es la interfaz pública TUploadedFiles la cual puede usarse para acceder a los archivos:
216	216
217	217		``` pascal
218	218		TUploadedFiles = Class(TCollection)
219	219		·
220	220		·
221	221		·
222	222		public
223	223		Function First: TUploadedFile;
224	224		Function Last: TUploadedFile;
225	225		Function IndexOfFile(AName: String) : Integer;
226	226		Function FileByName(AName: String) : TUploadedFile;
227	227		Function FindFile(AName: String) : TUploadedFile;
228	228		Property Files[Index: Integer] : TUploadedFile read GetFile Write SetFile; default;
229	229		end;
230	230		```
231	231
232	232		// Cada TUploadedFile por sí mismo tiene varias propiedades:
233	233
234	234		``` pascal
235	235		TUploadedFile = Class(TCollectionItem)
236	236		·
237	237		·
238	238		·
239	239		Public
240	240		Destructor Destroy; override;
241	241		Property FieldName: String Read FFieldName Write FFieldName;
242	242		Property FileName: String Read FFileName Write FFileName;
243	243		Property Stream: TStream Read GetStream;
244	244		Property Size: Int64 Read FSize Write FSize;
245	245		Property ContentType: String Read FContentType Write FContentType;
246	246		Property Disposition: String Read FDisposition Write FDisposition;
247	247		Property LocalFileName: String Read FLocalFileName Write FLocalFileName;
248	248		Property Description: String Read FDescription Write FDescription;
249	249		end;
250	250		```
251	251
252	252		Debería ser lo suficientemente descriptivo, con la excepción de FileName y LocalFileName. FileName es el archivo original name como se subió desde el cliente, LocalFileName es la ruta del archivo en el servidor donde el archivo se guarda de forma temporal. Note la diferencia en los términos en negrita antes descritos.
253	253
254	254		Nuevamente, reusemos el mismo manejador de petición, nótese que se puede optimizar el código usando una constante Req:
255	255
256	256		``` pascal
257	257		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
258	258		AResponse: TResponse; var Handled: Boolean);
259	259		const
260	260		Req = '<form id="form" action="%d" method=POST enctype="multipart' +
261	261		'/form-data"><label for="name">Drag n drop or click to' +
262	262		' add file:</label><input type="file" name="input" />' +
263	263		'<input type="submit" value="Send" /></form>';
264	264		var
265	265		n, i: Integer;
266	266		f: TUploadedFile;
267	267		begin
268	268		n := ARequest.Files.Count;
269	269		if n = 0 then
270	270		with AResponse.Contents do
271	271		Add(Req, [ARequest.URI])
272	272		else begin
273	273		f := ARequest.Files[0];
274	274		AResponse.Contents.LoadFromStream(f.Stream);
275	275		end;
276	276		Handled := true;
277	277		end;
278	278		```
279	279
280	280		arrastrar y soltar un archivo (preferiblemente texto, tal si fuese presentado como texto) en el campo de entrada de archivo (o clique el botón respectivo) entonces clique en el botón Enviar. El contenido de archivo deberá mostrarse.
281	281
282	282		## Cookies
283	283
284	284		### Configuración
285	285
286		-	<img src="cookie_session_Object_Pascal.png" title="El concepto de "cookie" (por el monstruo comegalletas?), inventado por Netscape en 1994, para permitir al servidor HTTP identificar a todos sus clientes." width="450" alt="El concepto de "cookie" (por el monstruo comegalletas?), inventado por Netscape en 1994, para permitir al servidor HTTP identificar a todos sus clientes." />\
	286	+	![El concepto de "cookie" (por el monstruo comegalletas?), inventado por Netscape en 1994, para permitir al servidor HTTP identificar a todos sus clientes.](cookie_session_Object_Pascal.png "El concepto de "cookie" (por el monstruo comegalletas?), inventado por Netscape en 1994, para permitir al servidor HTTP identificar a todos sus clientes.")\
287	287		El guardar y mantener las cookies son responsabilidad del navegador, por tanto el servidor necesita enviarlo como parte de la respuesta para mantener una. AResponse.Cookies contiene una lista de cookies a enviarse. Es descendiente de TCollection, respectivamente el TCookie contenido es descendiente de TCollectionItem. Por lo tanto, puede usar TCollection en la forma de manejar items para manipularlo.
288	288
289	289		Aquí un ejemplo:
290	290
291	291		``` pascal
292	292		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
293	293		AResponse: TResponse; var Handled: Boolean);
294	294		var
295	295		C: TCookie;
296	296		begin
297	297		C := AResponse.Cookies.Add;
298	298		C.Name := 'miCookie';
299	299		C.Value := 'algunValor';
300	300		Handled := true;
301	301		end;
302	302		```
303	303
304	304		No verá ninguna salida en su navegador. Pero si usa alguna herramienta de navegador (Chrome y Brave tienen una incorporada), puede ver el encabezado de la respuesta:
305	305
306	306		![](/wiki-images/6/69/Fpwebtutorial_cookie_set.png)
307	307
308	308		Note que la cookie tiene atributos, así que Name y Value no son las únicas cosas que pueda poner. Navegue por la interfaz de TCookie para ver qué propiedades soporta.
309	309
310	310		### Obteniéndola
311	311
312	312		Una vez se da el encabezado Set-Cookie arriba, la subsecuente petición a su sitio contendrá un encabezado adicional que contiene el valor que solicitó previamente poner:
313	313
314	314		![](/wiki-images/9/93/Fpwebtutorial_cookie_get.png)
315	315
316	316		Afortunadamente, la forma de leerla no es distinta de los datos GET o POST. La propiedad relacionada es ARequest.CookieFields. Para leer una cookie previamente puesta:
317	317
318	318		``` pascal
319	319		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
320	320		AResponse: TResponse; var Handled: Boolean);
321	321		begin
322	322		AResponse.Contents.Add('<p>La Cookie tiene:%d</p>', [ARequest.CookieFields.Values['miCookie']);
323	323		Handled := true;
324	324		end;
325	325		```
326	326
327	327		## Sesiones
328	328
329	329		TFPWebModule es un descendiente de TSessionHTTPModule, así que tiene capacidad de manejo de sesiones. La sesión está basada en módulos, así que cada módulo puede escoger usar o no el manejo de sesiones.
330	330
331	331		La sesión se implementa de forma abstracta. Por defecto, no se provee implementación. Un ejemplo de implementación usando archivos .ini está en la unidad iniwebsession. Debe tener esta unidad en su proyecto o implementar una para que el manejo de sesión funcione. Si decide implementar uno, básicamente necesita extender e implementar métodos abstractos en las clases TCustomSession y TSessionFactory.
332	332
333	333		### Activando la Sesión
334	334
335	335		Para activar el manejo de sesión, ponga la propiedad CreateSession en true. La sesión será iniciada antes del manejo de la petición. En caso de una nueva sesión, OnNewSession será invocado. Inicialice sus variables de sesión aquí.
336	336
337	337		### Manipulación de las Variables de Sesión
338	338
339	339		Las variables de sesión se proveen como Session.Variables (nb: el objeto Session es el equivalente al arreglo \$_SESSION que se usa en PHP). Esto es una estructura parecida a mapa de cadenas, así que puede leer / escribir así:
340	340
341	341		``` pascal
342	342		Session.Variables['miVar'] := miVar; // escritura
343	343		...
344	344		miVar := Session.Variables['miVar']; // lectura
345	345		```
346	346
347	347		Poner una variable como cadena vacía NO la remueve. En vez de eso, si realmente quiere remover una variable, llame Session.RemoveVariable.
348	348
349	349		### Terminando la Sesión
350	350
351	351		Llame Session.Terminate cuando quiera terminar una sesión (p.e.: logout del usuario). La sesión también expirará automáticamente si la siguiente petición viene después de Session.TimeOutMinutes desde la última petición. Cuando termina la sesión, OnSessionExpired será invocado. Haga toda la limpieza que necesite aquí.
352	352
353	353		## Enrutamiento
354	354
355	355		Desde la versión FPC 3.0.4, un nuevo mecanismo se ha implementado. En vez de mantener compatibilidad con lo anterior, se ha decidido que el nuevo enrolamiento será por defecto. Así cualquier código anterior (o nuevo código dependiendo en el enrolamiento anterior) debe actualizarse agregando:
356	356
357	357		``` pascal
358	358		Application.LegacyRouting := true;
359	359		```
360	360
361	361		en el archivo .lpr.
362	362
363	363		### Mecanismo Anterior
364	364
365	365		#### usando Múltiples Módulos
366	366
367	367		Puede tener múltiples módulos en su aplicación. Clique el menú "Archivo", luego clique "Nuevo…". Un cuadro de diálogo deberá aparecer, seleccione "Web Module".
368	368
369	369		![](/wiki-images/e/e5/Fpwebtutorial_new_module.png)
370	370
371	371		luego clique en Aceptar.
372	372
373	373		Dado que existen múltiples módulos en su aplicación, ya no puede solicitar sólo con /. El marco de trabajo no podrá seleccionar mágicamente qué módulo debe servir la respuesta, por lo que hay dos formas de indicar a qué módulo le gustaría llamar:
374	374
375	375		- /\<nombre del módulo\>
376	376		- /?modulo=\<nombre del módulo\>
377	377
378	378		En el segundo formato, puede cambiar "módulo" (que es el valor por defecto) a cualquier clave de cadena de consulta válida modificando Application.ModuleVariable
379	379
380	380		#### Usando Actions
381	381
382	382		Hasta ahora, sólo hemos usado módulos web con un solo manejador de peticiones. Esto no escala mucho a medida que su aplicación web se vuelve más y más compleja. Además, algunas funciones pueden tener propiedades compartidas y es mejor agruparlas de forma lógica, por ejemplo:
383	383
384	384		- Módulo Contable
385	385		- Action para Ingreso
386	386		- Action para Salir
387	387		- Action para Registro
388	388		- Módulo de Productos
389	389		- Action para Crear
390	390		- Action para Actualizar
391	391		- Action para Eliminar
392	392		- Action para Detalles
393	393
394	394		##### Flujo de Manejo de Peticiones
395	395
396	396		Antes de usar un Action, es importante que conozca el manejo de peticiones de fpWeb. Si no lo hace podría inutilizar su Action porque es siempre su módulo de datos que maneja la petición. Cómo podría pasar eso? Retroceda algunos capítulos, recuerda el Handled := true que siempre hicimos al final de cada procedimiento? Aquí es donde el parámetro Handled entra en juego.
397	397
398	398		Cada petición irá a través del OnRequest del módulo primero, sin importar la acción solicitada. Sólo si no se pone Handled en true, la acción web OnRequest se ejecuta.
399	399
400	400		En general, el flujo de peticiones es:
401	401
402	402		![](/wiki-images/e/ea/Fpwebtutorial_request_flow.png)
403	403
404	404		Note el recuadro "Our Concern", es eso a lo que le pondremos nuestra atención.
405	405
406	406		##### Agregue Actions a los Módulos Web
407	407
408	408		Para agregar un Action, seleccione el módulo web luego vaya al Inspector de Objetos. En la pestaña de propiedades, seleccione Actions y clique el botón en la segunda columna.
409	409
410	410		![](/wiki-images/9/95/Fpwebtutorial_manage_actions.png)
411	411
412	412		Una ventana popup deberá aparecer donde puede agregar, eliminar y cambiar el orden de las acciones.
413	413
414	414		![](/wiki-images/d/db/Fpwebtutorial_edit_actions.png)
415	415
416	416		Presione Agregar, una nueva acción aparecerá en la lista. Selecciónela y luego vaya al Inspector de Objetos. Mostrará propiedades y eventos para esa nueva acción. Renombre la propiedad Name (este será el nombre que escribirá en la URL, así que dele un nombre corto, simple, pero descriptivo) como prefiera, escogeremos "Hola". Muévase a la pestaña de eventos, haga lo mismo que OnRequest para el módulo, clique el botón a la derecha de la fila OnRequest para crear el manejador de la petición.
417	417
418	418		![](/wiki-images/2/2e/Fpwebtutorial_action_onrequest.png)
419	419
420	420		Se le presentará en la misma interfaz OnRquest, pero esto es una acción de manejo web en vez de un módulo web. Cualquier cosa que haga en el módulo web OnRequest puede hacerse aquí también. Copie el cuerpo del método desde la sección "Hola, Mundo!".
421	421
422	422		Recuerde remover Handled := true del cuerpo previo del módulo web OnRequest (o remueva el evento completamente) para que la acción esté pendiente del manejo de la petición.
423	423
424	424		Ejecute su proyecto, y encienda su navegador. Ahora, mientras se delega al manejo de petición la acción web, no podrá sólo pedir /, sino que necesita /\<nombre de la acción\> o propiedad ActionVar del Módulo\>=\<nombre de la acción\>. Note que \<propiedad del Módulo de ActionVar\> tiene un valor por defecto de cadena vacía, a diferencia de Application.ModuleVariable el cual tiene "module" como el valor por defecto. Así que, por defecto, puede sólo usarse el formulario /\<nombre de la acción\>.
425	425
426	426		Si tiene múltiples módulos, entonces tiene una variedad de opciones:
427	427
428	428		- /\<nombre del módulo\>/\<nombre de la acción\>
429	429		- /\<nombre del módulo\>?action=\<nombre de la acción\>
430	430		- /\<nombre de la acción\>?module=\<nombre del módulo\>
431	431		- /?module=\<nombre del módulo\>&action=\<nombre de la acción\>
432	432
433	433		Note que tan pronto como un módulo tenga al menos una acción, /\<nombre de la acción o del módulo\> en solitario se dirigirá por defecto a /\<nombre de la acción\>. Para cambiar el comportamiento de tal forma que se dirija a /\<nombre del módulo\> por defecto, ponga Application.PreferModuleName en true. En el caso de múltiples módulos, si no se ha dado nombre de módulo, entonces el módulo por defecto manejará la acción dada. Para cambiar el comportamiento de ese módulo, el nombre debe darse de forma explícita, ponga Application.AllowDefaultModule en false.
434	434
435	435		Las siguientes tablas resumen lo que pasará basado en las dos propiedades:
436	436
437	437		<thead>
438	438
439	439		</thead>
440	440		<tbody>
441	441
442	442		</tbody>
443	443
444	444		##### Acción por Defecto
445	445
446	446		Recuerde el diagrama previo, el "Delegar el manejo de peticiones a las acciones" actualmente no es tan simple, pero si expandimos el diagrama, la imagen será demasiado grande para que quepa. Así que aquí está el diagrama de esa parte:
447	447
448	448		![](/wiki-images/4/44/Fpwebtutorial_request_delegation_flow.png)
449	449
450	450		Dos cosas importantes del flujo: DefActionWhenUnknown y una acción por defecto. El formador es una propiedad del módulo web mientras que el último corresponde a la propiedad Default de una acción. En el último caso, en el que haya más de dos acciones que tengan la propiedad Default en true, el orden de las acciones (tal como se muestra en la ventana popup de manejo de acciones) será considerada a decidir cuál es la acción por defecto. Las dos propiedades forman lo que la aplicación debería hacer si no se encuentra una acción correspondiente para una petición dada.
451	451
452	452		Las siguientes tablas resumen lo que pasará basado en las dos propiedades:
453	453
454	454		<thead>
455	455
456	456		</thead>
457	457		<tbody>
458	458
459	459		</tbody>
460	460
461	461		<thead>
462	462
463	463		</thead>
464	464		<tbody>
465	465
466	466		</tbody>
467	467
468	468		En caso de la respuesta de error arriba, una traza de pila deberá aparecer, completa con la información del número de línea si construyó su aplicación con la opción -gl. Veremos luego cómo crear un manejador personalizado para esta (las trazas de pila no son buenas para la producción). Pero por ahora, asegúrese que entiende el concepto del módulo de web y las acciones web, especialmente el flujo de peticiones. Juegue con el código hasta que crea estar listo para la siguiente sección.
469	469
470	470		### Nuevo Mecanismo
471	471
472	472		El nuevo mecanismo es extremadamente flexible y funciona incluso sin módulos de datos (el viejo mecanismo sólo funciona con módulos de datos).
473	473
474	474		Una unidad dedicada para este enrolamiento se provee como httproute (agregue esto a la cláusula uses del programa o unidad donde quiera registrar las rutas). La unidad contiene una función HTTPRouter que retornará un objeto solitario responsable por la administración de las rutas de la aplicación y tiene un método RegisterRoute para registrar su ruta.
475	475
476	476		#### Sintáxis de la Ruta
477	477
478	478		El primer parámetro de HTTPRouter.RegisterRoute es la ruta que se emparejará con la petición entrante. Puede ser tan simple como un asterisco ***, el cual significa 0 ó más rutas o simplemente cualquier ruta, tan complejo como /api/v1/:resource/* el cual significa REQUEST_URI el encabezado debería iniciar con /api/v1/** seguido por algo que será unido a la variable del recurso nombrada y finalmente termina con 0 o más rutas. Será ajustable con:
479	479
480	480		- /api/v1/products
481	481		- /api/v1/products/1
482	482		- /api/v1/products/1/clone
483	483		- /api/v1/products/something/else/that/is/really/long/and/silly
484	484
485	485		pero no con:
486	486
487	487		- /api/v1
488	488		- /excuse/me/api/v1/products
489	489
490	490		Básicamente hay sólo 3 caracteres especiales:
491	491
492	492		- * que denota 0 o más rutas
493	493
494	494		-
495	495		param denota una parte
496	496
497	497		- / separador de partes
498	498
499	499		su ruta se compondrá de estos 3 caracteres, además cualquier cosa que conforme una ruta.
500	500
501	501		#### Registrar una Ruta
502	502
503	503		El 2º, 3º o 4º parámetro (dependiendo en lo que desee, manejar un método HTTP específico y/o pasar datos adicionales en él) de HTTPRouter.RegisterRoute está sobrecargado con varias posibilidades:
504	504
505	505		- Procedimiento Callback
506	506
507	507		``` pascal
508	508		TRouteCallback = Procedure(ARequest: TRequest; AResponse);
509	509		```
510	510
511	511		- Evento Callback
512	512
513	513		``` pascal
514	514		TRouteEvent = Procedure(ARequest: TRequest; AResponse) of object;
515	515		```
516	516
517	517		- Objeto que satisface una interfaz (CORBA)
518	518
519	519		``` pascal
520	520		IRouteInterface = Interface ['{10115353-10BA-4B00-FDA5-80B69AC4CAD0}']
521	521		Procedure HandleRequest(ARequest: TRequest; AResponse: TResponse);
522	522		end;
523	523		```
524	524
525	525		- Objeto que extiende una clase de enrutador abstracto
526	526
527	527		``` pascal
528	528		TRouteObject = Class(TObject, IRouteInterface)
529	529		Public
530	530		Procedure HandleRequest(ARequest: TRequest; AResponse: TResponse); virtual; abstract;
531	531		end;
532	532
533	533		TRouteObjectClass = Class of TRouteObject;
534	534		```
535	535
536	536		Por defecto, si el 2º parámetro no es TRouteMethod, entonces todos los métodos HTTP concordarán. Use alguno de estos rmUnknown, rmAll, rmGet, rmPost, rmPut, rmDelete, rmOptions, rmHead, rmTrace para concordar sólo con un método HTTP específico.
537	537
538	538		El orden de registro importa. Si hay dos o más rutas que concuerdan con la petición actual, el que se registró antes se manejará.
539	539
540	540		En este nuevo mecanismo, un simple programa Hola, Mundo! puede ser tan simple como:
541	541
542	542		``` pascal
543	543		uses
544	544		fphttpapp, httpdefs, httproute;
545	545		procedure DigaHola(ARequest:TRequest; AResponse : TResponse);
546	546		begin
547	547		AResponse.Content:='<html><body><h1>Hola, Mundo!</h1></body></html>';
548	548		end;
549	549
550	550		begin
551	551		HTTPRouter.RegisterRoute('*', @DigaHola);
552	552		Application.Port := 9000;
553	553		Application.Initialize;
554	554		Application.Run;
555	555		end.
556	556		```
557	557
558	558		#### Ejemplo Webserver
559	559
560	560		Este es un ejemplo de un servidor simple, multi-plataforma, multi-hilos.
561	561
562	562		``` pascal
563	563		program webserver;
564	564
565	565		{$mode objfpc}{$H+}
566	566
567	567		uses
568	568		{$ifdef UNIX}
569	569		cthreads, cmem,
570	570		{$endif}
571	571		fphttpapp, httpdefs, httproute;
572	572
573	573		procedure route1(aReq: TRequest; aResp: TResponse);
574	574		begin
575	575		aResp.content:='<html><body><h1>Ruta 1 Por Defecto</h1></body></html>'
576	576		end;
577	577
578	578		procedure route2(aReq: TRequest; aResp: TResponse);
579	579		begin
580	580		aResp.content:='<html><body><h1>Ruta 2</h1></body></html>'
581	581		end;
582	582
583	583		begin
584	584		HTTPRouter.registerRoute('/', @route1, true);
585	585		HTTPRouter.registerRoute('/route2', @route2);
586	586		Application.port := 8080;
587	587		Application.threaded := true;
588	588		Application.initialize;
589	589		Application.run;
590	590		end.
591	591		```
592	592
593	593		Para abrir la "Ruta 1" teclee en su navegador la URL: <http://localhost:8080>
594	594
595	595		Para abrir la "Ruta 2" teclee en su navegador la URL: <http://localhost:8080/route2>
596	596
597	597		Puede cambiar localhost por 127.0.0.1
598	598
599	599		## Usando Plantillas
600	600
601	601		fpWeb ha integrado soporte para FPTemplate, el motor de plantillas genérico de Free Pascal. No tiene que ser usado desde el contexto de la aplicación web, pero con soporte integrado las cosas serán un poco más fáciles. Al menos el administrador de memoria puede ser ignorado mientras el módulo se encarga de eso.
602	602
603	603		Hay dos niveles donde se puede usar plantillas: action y módulo. El soporte completo del RAD está incompleto, así que necesitará codificar por su cuenta en algunos puntos.
604	604
605	605		Hay dos modos de operación: parametrizados y no parametrizados. El modo activo está controlado por la propiedad AllowTagParams, la cual deberá ser suficientemente obvia con los valores que se refieren a los modos.
606	606
607	607		La cadena de plantilla puede obtenerse desde un archivo a través de la propiedad FileName o una cadena directa a través de la propiedad de plantilla Template. Si ambas propiedades contienen valores, entonces tendrá preferencia FileName.
608	608
609	609		Las dos propiedades: StartDelimiter y EndDelimiter definen cómo el motor debería reconocer una etiqueta de plantilla. Por ejemplo, si se tiene:
610	610
611	611		- StartDelimiter = '{+'
612	612		- EndDelimiter = '+}'
613	613
614	614		entonces una cadena '{+titulo+}' define una plantilla llamada 'titulo'. Nótese que los espacios son importantes, así que '{+ titulo +}' define una plantilla llamada ' titulo ' en vez de sólo 'titulo'.
615	615
616	616		En especial para el modo parametrizado, tres propiedades adicionales: ParamStartDelimiter, ParamEndDelimiter y ParamValueSeparator definen cómo el motor debe reconocer un parámetro de etiqueta de plantilla. Por ejemplo, si tiene:
617	617
618	618		- ParamStartDelimiter = '\[-'
619	619		- ParamEndDelimiter = '-\]'
620	620		- ParamValueSeparator = '='
621	621
622	622		entonces una cadena '{+data \[-p=v-\]\[-a=b-\] +}' define una etiqueta de plantilla llamada 'data' con el parámetro 'p' de valor 'v' y el parámetro 'a' de valor 'b'. Puede usarse para pasar el parámetro de nivel de plantilla tal como se espera, en formato de fecha, encabezado-fila-pieDePágina para una presentación personalizada, nombre de archivo, etc. usted decide.
623	623
624	624		Como consecuencia de distintas formas de operar, el evento central donde la etiqueta de plantilla trabaja es diferente también.
625	625
626	626		El no-parametrizado usará OnGetParam mientras que el parametrizado usará OnReplaceTag. Los dos tienen por supuesto, diferentes interfaces:
627	627
628	628		``` pascal
629	629		Type
630	630		// OnGetParam: para simple soporte exclusivo de etiquetas de plantilla (ej: {Nombre})
631	631		TGetParamEvent = Procedure(
632	632		Sender: TObject;
633	633		Const ParamName: String;
634	634		Out AValue: String
635	635		) Of Object;
636	636		// OnReplaceTag: para etiquetas con soporte de parámetros
637	637		TReplaceTagEvent = Procedure(
638	638		Sender: TObject;
639	639		Const TagString: String;
640	640		TagParams: TStringList;
641	641		Out ReplaceText: String
642	642		) Of Object;
643	643		```
644	644
645	645		En OnGetParam, compruebe ParamName, luego asigne AValue respectivamente. p.e., si quiere etiquetar 'titulo' para ser reemplazado por 'Mi App', entonces llene el método con:
646	646
647	647		``` pascal
648	648		// use Trim() si quiere que los espacios alrededor de la etiqueta no importen
649	649		case Trim(ParamName) of
650	650		'titulo': AValue := 'Mi App';
651	651		else
652	652		AValue := 'DESCONOCIDO';
653	653		end;
654	654		```
655	655
656	656		En OnReplaceTag, compruebe TagString y opcionalmente TagParams, luego asigne ReplaceText respectivamente. p.e., si quiere que la etiqueta 'FechaHora' se reemplace con el tiempo actual con el parámetro 'datetimeformat' para especificar cómo la fecha y hora deberían formatearse, luego llene en el método así:
657	657
658	658		``` pascal
659	659		// use Trim() si quiere que los espacios alrededor de la etiqueta no importen
660	660		case Trim(TagString) of
661	661		'FechaHora': AValue := FormatDateTime(TagParams.Values['datetimeformat'],Now);
662	662		else
663	663		AValue := 'DESCONOCIDO';
664	664		end;
665	665		```
666	666
667	667		### Al Nivel de la Acción
668	668
669	669		Cree/seleccione una acción, luego vaya al inspector de objetos. Verá una propiedad de subcomponente llamada Template. Esta plantilla es una instancia normal de TFPTemplate. Expándalo y llene en las propiedades como se explicó arriba. Ahora vaya a la pestaña Eventos, nuevamente expanda Template, verá los dos eventos. Llene el que está basado en su valor de propiedad de AllowTagParams.
670	670
671	671		NOTA: Si su Lazarus no puede autocompletar el evento, intente escribir el nombre manualmente en el cuadro de edición y luego clique el botón ···. Este es un bug en el Lazarus actual que deberá ser arreglado en el futuro.
672	672
673	673		A este nivel, la plantilla con contenido no se ajusta automáticamente como el manejador de petición. Podría cambiar en el futuro, pero trabajemos con su estado actual. Llene el evento de la acción OnRequest con:
674	674
675	675		``` pascal
676	676		with Actions.CurrentAction as TFPWebAction do
677	677		begin
678	678		AResponse.Content := Template.GetContent;
679	679		end;
680	680		Handled := true;
681	681		```
682	682
683	683		El cast es requerido desde que CurrentAction es de tipo TCustomWebAction en vez de TFPWebAction. Sin eso, no podemos acceder a la propiedad Template.
684	684
685	685		### A Nivel de Módulo
686	686
687	687		A nivel del módulo, actualmente tiene que codificarlo porque no se ha implementado soporte para RAD. La propiedad a vincular es ModuleTemplate. Esto es sin embargo una instancia irregular de TFPTemplate, pero una clase especial TFPWebTemplate que es descendiente de ella.
688	688
689	689		La idea aquí es que el módulo proporcione un diseño mientras que las acciones proporcionan contenido, con la capacidad de proporcionar variables adicionales. Por tanto, es buena idea mantener AllowTagParams como está y asignar el evento OnGetParam del módulo solamente. NO asigne OnGetParam del ModuleTemplate ya que nunca será llamado.
690	690
691	691		Una etiqueta de plantilla llamada 'contenido' se reemplazará automáticamente por el contendido producido por la acción, todo lo demás es reemplazado desde las variables internas de plantilla o desde OnGetParam.
692	692
693	693		### Usando Plantillas por Separado
694	694
695	695		A pesar de la integración algo incompleta, nada le impide usar fpTemplate (o cualquier otra solución de plantillas) manualmente, fuera del soporte integrado. Esto podría incluso ser mejor en algunos casos ya que es modular.
696	696
697	697		## Usando un objeto html Producer
698	698
699	699		Suponiendo que hay una TWebAction llamada act_get_my_html, debe solicitar escribir en AResponse, el retorno de una corriente de bytes interna: al responder con la solución de objetos html Producer, debemos usar los métodos del escritor. Maneja una corriente de memoria con el propósito de mayor rapidez. No hay tipo de cadena aquí, como con la solución fpTemplate anterior que utiliza el procesamiento de texto \\ cadena como en la forma normal de PHP. El Productor escribe en AResponse con una iteración recursiva " para cada elemento ", que atraviesa el árbol HTML DOM de objetos polimórficos, compuesto por la jerarquía de clases THtmlCustomElement = Class(TDOMElement) (vea la unidad htmlelements.pp). Entonces, AResponse se escribe mediante el parámetro aWriter, con la siguiente llamada:
700	700
701	701		``` pascal
702	702		procedure TFPWebModule1.act_get_my_htmlRequest(Sender: TObject; ARequest: TRequest; AResponse: TResponse; var Handled: Boolean);
703	703		begin
704	704		(* pide a HTMLEntityProducer1 el contenido de sus elementos html DOM: *)
705	705		HTMLEntityProducer1.HandleRequest(ARequest, AResponse, Handled);
706	706		Handled := True;
707	707		end;
708	708		```
709	709
710	710		Dicho de nuevo, es trabajo del Productor convertir su corriente interna de memoria a texto en el objeto de la respuesta: así es como se diseñó este patrón, aunque hay un método de representación de texto-html llamado ProduceContent solo con fines de depuración. Puede sobrecargar este método si está escribiendo o depurando un componente Producer.
711	711
712	712		Aquí hay un ejemplo, con un objeto Producer html, que permite crear una aplicación web al "modo RAD", es decir, con el arrastrar y soltar del componente HTMLEntityProducer desde la paleta de componentes:
713	713
714	714		``` pascal
715	715		procedure TFPWebModule1.HTMLEntityProducer1WriteEntity(Sender: THTMLContentProducer; aWriter: THTMLWriter);
716	716		begin // HTMLEntityProducer has Entity := heHtml
717	717		aWriter.StartHead; // .startHeader;
718	718		aWriter.Meta('','Content-Type','text/html; charset=UTF-8');
719	719		aWriter.title('My web page');
720	720		aWriter.link('stylesheet','stylesheet.css','text/css','screen');
721	721		aWriter.EndHead; // .endHeader;
722	722
723	723		aWriter.Startbody;
724	724		aWriter.StartParagraph;
725	725		aWriter.heading2('Hola, mundo desde adentro §1:');
726	726		aWriter.Text('Esto es texto escrito dentro del párrafo actual.');
727	727		aWriter.EndParagraph;
728	728		aWriter.paragraph('Otro texto dentro de un párrafo "iniciado y terminado" por sí mismo.');
729	729		aWriter.StartP; // .StartParagraph;
730	730		aWriter.tagH2('Hola, mundo desde adentro §2:'); // .heading2;
731	731		aWriter.Text('Aquí está el texto final.');
732	732		aWriter.Image.src := 'logo.png';
733	733		AnotherProducer.WriteContent(aWriter);
734	734		aWriter.EndP; // .EndParagraph;
735	735		// you can use tags and other THtmlCustomElements
736	736		aWriter.tagP([aWriter.bold('Hola'), aWriter.tagQ('Mundo!')]);
737	737		aWriter.Text('<u>Hola,</u><i>mundo!</i>');
738	738		aWriter.Endbody;
739	739
740	740		end;
741	741		```
742	742
743	743		La propiedad TWebAction.ContentProducer permite acoplar un THTTPContentProducer a su acción web expuesta a través de una URI en la red.
744	744
745	745		\[PorHacer: no hay documentación oficial acerca de los componentes "RAD way" de ftweb (html producer, html provider, html adapter, html formatter, etc)\]
746	746
747	747		## Trucos y Consejos
748	748
749	749		### Retornando Distintos Códigos de Respuesta HTTP
750	750
751	751		Por defecto, fpWeb retornará HTTP 200 OK para indicar un manejo de respuesta exitoso. Esto de seguro no siempre es el caso, como las entradas del usuario no puedan ser lo que esperamos. Para hacerlo, modifique AResponse.Code en su manejador de peticiones en el código que desee retornar.
752	752
753	753		### Redirigir Peticiones a Diferentes URLs
754	754
755	755		Un flujo común después de un login es redirigir al usuario a su página de cuenta. Esto se puede hacer llamando AResponse.SendRedirect en su manejador de petición, ordenando a la URL que redirija la petición.
756	756
757	757		### Sirviendo Archivos Estáticos (Servidor Web Embebido)
758	758
759	759		Recuerda el diálogo en la sección #Hola, Mundo! después que seleccione la Aplicación servidora HTTP? Si escogió "Registre ubicación de dónde servir archivos" puede llenar "Ubicación" (el segmento URI, no debe contener ningún slash) y "Directorio" (directorio físico en su computador, debe existir en tiempo de ejecución) y el asistente simplemente agrega:
760	760
761	761		``` pascal
762	762		RegisterFileLocation('<Location>','<Directory>');
763	763		```
764	764
765	765		al comienzo de su archivo .lpr y agrega la unidad fpwebfile a su cláusula uses. Puede actualmente hacer esto a mano en cualquier momento y también registrar múltiples veces para diferentes ubicaciones / directorios. Después de esto puede pedir /\<Ubicación\>/\<cualquier nombre de archivo dentro del Directorio\> y será servido automáticamente. Note que el mimetype del archivo se determina por fpmimetypes. Llame MimeTypes.LoadFromFile con su archivo mime.types para dar un mimetype correcto basado en su extensión. De otra forma, el archivo siempre se servirá como application/octet-stream el cual significa que el navegador lo descargará en vez de interpretarlo (especialmente importante para JavaScript y archivos CSS).
766	766
767	767		Puede aprovechar los mime.types completos aquí <http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/conf/mime.types?&view=co>
768	768
769	769		En Lazarus 2.0.6 o más reciente versión debe agregar en el comienzo del programa la ruta completa de los archivos mime.type
770	770
771	771		``` pascal
772	772		begin
773	773		MimeTypesFile := Application.Location + 'mime.txt';
774	774		```
775	775
776	776		Tenga en cuenta que la ruta por defecto que viene con el proyecto es lib\\\$(TargetCPU)-\$(TargetOS)
777	777
778	778		por ejemplo httpproject\lib\i386-win32\mime.txt
779	779
780	780		### Centralice la Administración de la Configuración y los Módulos
781	781
782	782		Por defecto, el archivo (.lpr) es el único que contiene la unidad de protocolo. Esto limita la habilidad de usar el objeto Application de otros contextos como los módulos web. Afortunadamente, esto no dificulta refactorizar lo que queremos tener. Removemos las llamadas RegisterHTTPModule desde las unidades de los módulos web dejamos al .lpr que extraiga para vaciar el bloque principal con un identificador simple de unidad en la cláusula uses, lo nombramos: agentes (Brokers). La unidad contiene:
783	783
784	784		``` pascal
785	785		unit Brokers;
786	786
787	787		{$mode objfpc}{$H+}
788	788
789	789		interface
790	790
791	791		{ $define cgi}
792	792		{ $define fcgi}
793	793		{$define httpapp}
794	794
795	795		uses
796	796		CustWeb;
797	797
798	798		function GetApp: TCustomWebApplication; inline;
799	799
800	800		implementation
801	801
802	802		uses
803	803		{$ifdef cgi}fpcgi{$endif}
804	804		{$ifdef fcgi}fpfcgi{$endif}
805	805		{$ifdef httpapp}fphttpapp{$endif}
806	806		,webmodule1
807	807		,webmodule2
808	808		;
809	809
810	810		function GetApp: TCustomWebApplication;
811	811		begin
812	812		Result := Application;
813	813		end;
814	814
815	815		initialization
816	816		RegisterHTTPModule('wm1', TWebModule1);
817	817		RegisterHTTPModule('wm2', TWebModule2);
818	818		{$ifndef cgi}
819	819		Application.Port := 2015;
820	820		{$endif}
821	821		Application.Initialize;
822	822		Application.Run;
823	823		end.
824	824		```
825	825
826	826		De esta forma, podemos controlar el registro del módulo web y también proveer un API para obtener el objeto Application (enmarcado como TCustomWebApplication), mientras todavía de forma fácil cambie entre los protocolos de implementación, en un sólo lugar.
827	827
828	828		### Terminando Adecuadamente (FastCGI / Servidor Web Embebido)
829	829
830	830		En vez de terminar la aplicación mediante Ctrl+C, hay una forma para que su aplicación termine adecuadamente, haciendo todo lo necesario para limpiar lo que necesite, llamando Application.Terminate. Podría necesitar usar el truco previo para acceder fácilmente al objeto Application. Una implementación común es proveer un módulo / acción específico protegido con contraseña que llame el método Terminate. Puede escoger la forma que prefiera.
831	831
832	832		### Manejador de Excepción Personalizada
833	833
834	834		\[edición de Mayo 1 de 2020 =\> movido desde un puntero de método a un simple de procedimiento.\]
835	835
836	836		Para pasar por delante del manejador de excepción por defecto, el cual imprime stacktrace cada vez que una excepción se genera (p.e.: HTTP 404 ó 500), y así no es bueno para la producción, debe asignar un Application.OnShowRequestException.
837	837
838	838		Este es un método que necesitará proveer su procedimiento que implemente el método y lo asigne usando el objeto. p.e.: si tiene MyExceptionHandler como un objeto TMyExceptionHandler el cual tiene un método MyShowRequestException, puede asignarlo mediante:
839	839
840	840		``` pascal
841	841		Application.OnShowRequestException := @MyExceptionHandler.MyShowRequestException;
842	842		```
843	843
844	844		no olvide .Create() MyExceptionHandler ANTES de asignar arriba u obtendrá un EAccessViolation!
845	845
846	846		Debe proveer un procedimiento global que implemente su propio manejador de excepción (en producción, es You must provide your global procedure that implements your own exception handler (in production, es recomendable reemplazar la pila de llamadas por un código de estado HTTP y su explicación). Luego puede pasar por delante el manejador de excepción por defecto, asignándolo así:
847	847
848	848		``` pascal
849	849		Application.OnShowRequestException := @MyShowRequestException;
850	850		```
851	851
852	852		### Codificando Sólo a Mano (Sin Diseñador de Formularios)
853	853
854	854		No es una obligación usar el diseñador de formularios para escribir una aplicación fpWeb. Puede usar técnicas de codificación a mano para escribirla. El secreto radica en el 3er parámetro de RegisterHTTPModule : SkipStreaming. Cuando este parámetro se pone en verdadero, fpWeb no buscará el recurso .lfm. Por tanto todo debe manejarse de forma manual: las opciones de propiedades, los maneadores de eventos, registro de acciones, etc.
855	855
856	856		Note que es lógico hacer lo que usualmente funciona a través del inspector de objetos en un constructor solapado. Dentro de él, llame al constructor heredado supliendo los parámetros AOwner y CreateMode. Después de eso puede poner propiedades, asignar maneadores de eventos, etc. Por ejemplo:
857	857
858	858		``` pascal
859	859		type
860	860		TModuloHolaMundo = class(TFPWebModule)
861	861		constructor CreateNew(AOwner: TComponent; CreateMode: Integer); override;
862	862		procedure Request(Sender: TObject; ARequest: TRequest;
863	863		AResponse: TResponse; var Handled: Boolean);
864	864		end;
865	865
866	866		constructor TModuloHolaMundo.CreateNew(AOwner: TComponent; CreateMode: Integer);
867	867		begin
868	868		inherited CreateNew(AOwner, CreateMode);
869	869		OnRequest := @Request;
870	870		end;
871	871
872	872		procedure TModuloHolaMundo.Request(Sender: TObject; ARequest: TRequest;
873	873		AResponse: TResponse; var Handled: Boolean);
874	874		begin
875	875		AResponse.Content := 'Hola, Mundo!';
876	876		Handled := true;
877	877		end;
878	878		```
879	879
880	880		## Vea También
881	881
882	882		- [Posiblemente el mismo contenido](https://github.com/leledumbo/fpWebTutorial)
883	883		- [Lazarus para la web (tutorial)](https://www.freepascal.org/~michael/articles/#web1)
884	884		- [Lazarus para la web: Sesiones y Plantillas (tutorial)](https://www.freepascal.org/~michael/articles/#web2) Este artículo explica una Clase TSQLDBSession que maneja una conexión SQL, que se hereda de una sesión web (para manejar el historial de las variables de sesión web, dentro de una sesión de conexión a una base de datos teniendo capacidades de bloqueo de fila).
885	885		- los ejemplos - lea los archivos de texto - en su directorio ...\fpc\x.x.x\source\packages\fcl-web\examples.\
886	886
887		-	~~<img src="cgi-listrecords.png" title="Screenshot copia de uno de los ejemplos" width="50" />~~
	887	+	![](/wiki-images/c/c0/Cgi-listrecords.png)
888	888
889	889		- XML o JSON, en ExtJS: si quiere usar un motor más o menos complejo que sea bastante "cumplidor" sin importar el aspecto que muestran los objetos Javascript en el lado del navegador, además de sus funcionalidades (como ExtJS, por ejemplo, para mostrar una grilla accesible a la base de datos, gráficos dinámicos, etc), esta clase de solución muchas veces espera por un archivo XML o JSON. Hay clases adaptadoras y formateadoras (p.e. las clases TExtJSXMLWebdataInputAdaptor, TExtJSJSONDataFormatter).
890	890
891	891		Sobre todo, las clases adaptadoras "adaptan" los nodos de un JSON o XML entrante a un mapeo de sus campos de base de datos TField. Y las clases formateadoras son mapeadores de cada Field de un registro en su nodo en formato JSON o XML, antes de enviarlo hacia el navegador.\
892	892		* [Formatos de datos Web en Lazarus/FPC](https://www.freepascal.org/~michael/articles/#webdata)
893	893
894	894		- [Construcción GUI práctica en ExtJS](https://www.freepascal.org/~michael/articles/#extjs1)
895	895		- [Combinando aplicaciones web ExtJS y Pascal: ExtPascal](https://www.freepascal.org/~michael/articles/#extpascal)
896	896
897	897		traducido por edgarrod71@gmail.com
898	898
899	899		---
900	900		From the Free Pascal wiki, page "fpWeb Tutorial/es", as it stood on 2023-03-19 after a change by Edgardager, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history