fpWeb Tutorial/es: what changed

Revision 2 to 3. 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		-	~~` Por favor dame tu nombre:`~~
	181	+	```text
	182	+	Por favor dame tu nombre:
	183	+	```
182	184
183	185		y al final de la dirección coloque /?name=\<escriba algo aquí, p.e.: Fernando\>, lo que mostrará
184	186
185		-	~~` Hola, Fernando!`~~
	187	+	```text
	188	+	Hola, Fernando!
	189	+	```
186	190
187	191		### Leyendo POST
188	192
189	193		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	194
191	195		``` pascal
192	196		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
193	197		AResponse: TResponse; var Handled: Boolean);
194	198		var
195	199		LName: String;
196	200		begin
197	201		LName := ARequest.ContentFields.Values['Name']; // ContentFields para POST
198	202		if LName = EmptyStr then
199	203		with AResponse.Contents do
200	204		begin
201	205		Add('<form action="%d" method="POST"', [ARequest.URI]);
202	206		Add('<label for="name">Por favor dame tu nombre:</label>');
203	207		Add('<input type="text" name="name" id="name" />');
204	208		Add('<input type="submit" value="Send" />');
205	209		Add('</form>');
206	210		end
207	211		else
208	212		AResponse.Content := Format('<h1>Hola, %s!</h1>', [LName]);
209	213		Handled := true;
210	214		end;
211	215		```
212	216
213	217		### Leyendo Subir Archivos
214	218
215	219		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	220
217	221		``` pascal
218	222		TUploadedFiles = Class(TCollection)
219	223		·
220	224		·
221	225		·
222	226		public
223	227		Function First: TUploadedFile;
224	228		Function Last: TUploadedFile;
225	229		Function IndexOfFile(AName: String) : Integer;
226	230		Function FileByName(AName: String) : TUploadedFile;
227	231		Function FindFile(AName: String) : TUploadedFile;
228	232		Property Files[Index: Integer] : TUploadedFile read GetFile Write SetFile; default;
229	233		end;
230	234		```
231	235
232	236		// Cada TUploadedFile por sí mismo tiene varias propiedades:
233	237
234	238		``` pascal
235	239		TUploadedFile = Class(TCollectionItem)
236	240		·
237	241		·
238	242		·
239	243		Public
240	244		Destructor Destroy; override;
241	245		Property FieldName: String Read FFieldName Write FFieldName;
242	246		Property FileName: String Read FFileName Write FFileName;
243	247		Property Stream: TStream Read GetStream;
244	248		Property Size: Int64 Read FSize Write FSize;
245	249		Property ContentType: String Read FContentType Write FContentType;
246	250		Property Disposition: String Read FDisposition Write FDisposition;
247	251		Property LocalFileName: String Read FLocalFileName Write FLocalFileName;
248	252		Property Description: String Read FDescription Write FDescription;
249	253		end;
250	254		```
251	255
252	256		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	257
254	258		Nuevamente, reusemos el mismo manejador de petición, nótese que se puede optimizar el código usando una constante Req:
255	259
256	260		``` pascal
257	261		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
258	262		AResponse: TResponse; var Handled: Boolean);
259	263		const
260	264		Req = '<form id="form" action="%d" method=POST enctype="multipart' +
261	265		'/form-data"><label for="name">Drag n drop or click to' +
262	266		' add file:</label><input type="file" name="input" />' +
263	267		'<input type="submit" value="Send" /></form>';
264	268		var
265	269		n, i: Integer;
266	270		f: TUploadedFile;
267	271		begin
268	272		n := ARequest.Files.Count;
269	273		if n = 0 then
270	274		with AResponse.Contents do
271	275		Add(Req, [ARequest.URI])
272	276		else begin
273	277		f := ARequest.Files[0];
274	278		AResponse.Contents.LoadFromStream(f.Stream);
275	279		end;
276	280		Handled := true;
277	281		end;
278	282		```
279	283
280	284		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	285
282	286		## Cookies
283	287
284	288		### Configuración
285	289
286	290		![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	291		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	292
289	293		Aquí un ejemplo:
290	294
291	295		``` pascal
292	296		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
293	297		AResponse: TResponse; var Handled: Boolean);
294	298		var
295	299		C: TCookie;
296	300		begin
297	301		C := AResponse.Cookies.Add;
298	302		C.Name := 'miCookie';
299	303		C.Value := 'algunValor';
300	304		Handled := true;
301	305		end;
302	306		```
303	307
304	308		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	309
306	310		![](/wiki-images/6/69/Fpwebtutorial_cookie_set.png)
307	311
308	312		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	313
310	314		### Obteniéndola
311	315
312	316		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	317
314	318		![](/wiki-images/9/93/Fpwebtutorial_cookie_get.png)
315	319
316	320		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	321
318	322		``` pascal
319	323		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
320	324		AResponse: TResponse; var Handled: Boolean);
321	325		begin
322	326		AResponse.Contents.Add('<p>La Cookie tiene:%d</p>', [ARequest.CookieFields.Values['miCookie']);
323	327		Handled := true;
324	328		end;
325	329		```
326	330
327	331		## Sesiones
328	332
329	333		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	334
331	335		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	336
333	337		### Activando la Sesión
334	338
335	339		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	340
337	341		### Manipulación de las Variables de Sesión
338	342
339	343		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	344
341	345		``` pascal
342	346		Session.Variables['miVar'] := miVar; // escritura
343	347		...
344	348		miVar := Session.Variables['miVar']; // lectura
345	349		```
346	350
347	351		Poner una variable como cadena vacía NO la remueve. En vez de eso, si realmente quiere remover una variable, llame Session.RemoveVariable.
348	352
349	353		### Terminando la Sesión
350	354
351	355		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	356
353	357		## Enrutamiento
354	358
355	359		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	360
357	361		``` pascal
358	362		Application.LegacyRouting := true;
359	363		```
360	364
361	365		en el archivo .lpr.
362	366
363	367		### Mecanismo Anterior
364	368
365	369		#### usando Múltiples Módulos
366	370
367	371		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	372
369	373		![](/wiki-images/e/e5/Fpwebtutorial_new_module.png)
370	374
371	375		luego clique en Aceptar.
372	376
373	377		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	378
375	379		- /\<nombre del módulo\>
376	380		- /?modulo=\<nombre del módulo\>
377	381
378	382		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	383
380	384		#### Usando Actions
381	385
382	386		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	387
384	388		- Módulo Contable
385	389		- Action para Ingreso
386	390		- Action para Salir
387	391		- Action para Registro
388	392		- Módulo de Productos
389	393		- Action para Crear
390	394		- Action para Actualizar
391	395		- Action para Eliminar
392	396		- Action para Detalles
393	397
394	398		##### Flujo de Manejo de Peticiones
395	399
396	400		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	401
398	402		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	403
400	404		En general, el flujo de peticiones es:
401	405
402	406		![](/wiki-images/e/ea/Fpwebtutorial_request_flow.png)
403	407
404	408		Note el recuadro "Our Concern", es eso a lo que le pondremos nuestra atención.
405	409
406	410		##### Agregue Actions a los Módulos Web
407	411
408	412		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	413
410	414		![](/wiki-images/9/95/Fpwebtutorial_manage_actions.png)
411	415
412	416		Una ventana popup deberá aparecer donde puede agregar, eliminar y cambiar el orden de las acciones.
413	417
414	418		![](/wiki-images/d/db/Fpwebtutorial_edit_actions.png)
415	419
416	420		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	421
418	422		![](/wiki-images/2/2e/Fpwebtutorial_action_onrequest.png)
419	423
420	424		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	425
422	426		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	427
424	428		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	429
426	430		Si tiene múltiples módulos, entonces tiene una variedad de opciones:
427	431
428	432		- /\<nombre del módulo\>/\<nombre de la acción\>
429	433		- /\<nombre del módulo\>?action=\<nombre de la acción\>
430	434		- /\<nombre de la acción\>?module=\<nombre del módulo\>
431	435		- /?module=\<nombre del módulo\>&action=\<nombre de la acción\>
432	436
433	437		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	438
435	439		Las siguientes tablas resumen lo que pasará basado en las dos propiedades:
436	440
437	441		<thead>
438	442
439	443		</thead>
440	444		<tbody>
441	445
442	446		</tbody>
443	447
444	448		##### Acción por Defecto
445	449
446	450		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	451
448	452		![](/wiki-images/4/44/Fpwebtutorial_request_delegation_flow.png)
449	453
450	454		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	455
452	456		Las siguientes tablas resumen lo que pasará basado en las dos propiedades:
453	457
454	458		<thead>
455	459
456	460		</thead>
457	461		<tbody>
458	462
459	463		</tbody>
460	464
461	465		<thead>
462	466
463	467		</thead>
464	468		<tbody>
465	469
466	470		</tbody>
467	471
468	472		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	473
470	474		### Nuevo Mecanismo
471	475
472	476		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	477
474	478		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	479
476	480		#### Sintáxis de la Ruta
477	481
478	482		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	483
480	484		- /api/v1/products
481	485		- /api/v1/products/1
482	486		- /api/v1/products/1/clone
483	487		- /api/v1/products/something/else/that/is/really/long/and/silly
484	488
485	489		pero no con:
486	490
487	491		- /api/v1
488	492		- /excuse/me/api/v1/products
489	493
490	494		Básicamente hay sólo 3 caracteres especiales:
491	495
492	496		- * que denota 0 o más rutas
493	497
494	498		-
495	499		param denota una parte
496	500
497	501		- / separador de partes
498	502
499	503		su ruta se compondrá de estos 3 caracteres, además cualquier cosa que conforme una ruta.
500	504
501	505		#### Registrar una Ruta
502	506
503	507		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	508
505	509		- Procedimiento Callback
506	510
507	511		``` pascal
508	512		TRouteCallback = Procedure(ARequest: TRequest; AResponse);
509	513		```
510	514
511	515		- Evento Callback
512	516
513	517		``` pascal
514	518		TRouteEvent = Procedure(ARequest: TRequest; AResponse) of object;
515	519		```
516	520
517	521		- Objeto que satisface una interfaz (CORBA)
518	522
519	523		``` pascal
520	524		IRouteInterface = Interface ['{10115353-10BA-4B00-FDA5-80B69AC4CAD0}']
521	525		Procedure HandleRequest(ARequest: TRequest; AResponse: TResponse);
522	526		end;
523	527		```
524	528
525	529		- Objeto que extiende una clase de enrutador abstracto
526	530
527	531		``` pascal
528	532		TRouteObject = Class(TObject, IRouteInterface)
529	533		Public
530	534		Procedure HandleRequest(ARequest: TRequest; AResponse: TResponse); virtual; abstract;
531	535		end;
532	536
533	537		TRouteObjectClass = Class of TRouteObject;
534	538		```
535	539
536	540		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	541
538	542		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	543
540	544		En este nuevo mecanismo, un simple programa Hola, Mundo! puede ser tan simple como:
541	545
542	546		``` pascal
543	547		uses
544	548		fphttpapp, httpdefs, httproute;
545	549		procedure DigaHola(ARequest:TRequest; AResponse : TResponse);
546	550		begin
547	551		AResponse.Content:='<html><body><h1>Hola, Mundo!</h1></body></html>';
548	552		end;
549	553
550	554		begin
551	555		HTTPRouter.RegisterRoute('*', @DigaHola);
552	556		Application.Port := 9000;
553	557		Application.Initialize;
554	558		Application.Run;
555	559		end.
556	560		```
557	561
558	562		#### Ejemplo Webserver
559	563
560	564		Este es un ejemplo de un servidor simple, multi-plataforma, multi-hilos.
561	565
562	566		``` pascal
563	567		program webserver;
564	568
565	569		{$mode objfpc}{$H+}
566	570
567	571		uses
568	572		{$ifdef UNIX}
569	573		cthreads, cmem,
570	574		{$endif}
571	575		fphttpapp, httpdefs, httproute;
572	576
573	577		procedure route1(aReq: TRequest; aResp: TResponse);
574	578		begin
575	579		aResp.content:='<html><body><h1>Ruta 1 Por Defecto</h1></body></html>'
576	580		end;
577	581
578	582		procedure route2(aReq: TRequest; aResp: TResponse);
579	583		begin
580	584		aResp.content:='<html><body><h1>Ruta 2</h1></body></html>'
581	585		end;
582	586
583	587		begin
584	588		HTTPRouter.registerRoute('/', @route1, true);
585	589		HTTPRouter.registerRoute('/route2', @route2);
586	590		Application.port := 8080;
587	591		Application.threaded := true;
588	592		Application.initialize;
589	593		Application.run;
590	594		end.
591	595		```
592	596
593	597		Para abrir la "Ruta 1" teclee en su navegador la URL: <http://localhost:8080>
594	598
595	599		Para abrir la "Ruta 2" teclee en su navegador la URL: <http://localhost:8080/route2>
596	600
597	601		Puede cambiar localhost por 127.0.0.1
598	602
599	603		## Usando Plantillas
600	604
601	605		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	606
603	607		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	608
605	609		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	610
607	611		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	612
609	613		Las dos propiedades: StartDelimiter y EndDelimiter definen cómo el motor debería reconocer una etiqueta de plantilla. Por ejemplo, si se tiene:
610	614
611	615		- StartDelimiter = '{+'
612	616		- EndDelimiter = '+}'
613	617
614	618		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	619
616	620		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	621
618	622		- ParamStartDelimiter = '\[-'
619	623		- ParamEndDelimiter = '-\]'
620	624		- ParamValueSeparator = '='
621	625
622	626		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	627
624	628		Como consecuencia de distintas formas de operar, el evento central donde la etiqueta de plantilla trabaja es diferente también.
625	629
626	630		El no-parametrizado usará OnGetParam mientras que el parametrizado usará OnReplaceTag. Los dos tienen por supuesto, diferentes interfaces:
627	631
628	632		``` pascal
629	633		Type
630	634		// OnGetParam: para simple soporte exclusivo de etiquetas de plantilla (ej: {Nombre})
631	635		TGetParamEvent = Procedure(
632	636		Sender: TObject;
633	637		Const ParamName: String;
634	638		Out AValue: String
635	639		) Of Object;
636	640		// OnReplaceTag: para etiquetas con soporte de parámetros
637	641		TReplaceTagEvent = Procedure(
638	642		Sender: TObject;
639	643		Const TagString: String;
640	644		TagParams: TStringList;
641	645		Out ReplaceText: String
642	646		) Of Object;
643	647		```
644	648
645	649		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	650
647	651		``` pascal
648	652		// use Trim() si quiere que los espacios alrededor de la etiqueta no importen
649	653		case Trim(ParamName) of
650	654		'titulo': AValue := 'Mi App';
651	655		else
652	656		AValue := 'DESCONOCIDO';
653	657		end;
654	658		```
655	659
656	660		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	661
658	662		``` pascal
659	663		// use Trim() si quiere que los espacios alrededor de la etiqueta no importen
660	664		case Trim(TagString) of
661	665		'FechaHora': AValue := FormatDateTime(TagParams.Values['datetimeformat'],Now);
662	666		else
663	667		AValue := 'DESCONOCIDO';
664	668		end;
665	669		```
666	670
667	671		### Al Nivel de la Acción
668	672
669	673		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	674
671	675		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	676
673	677		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	678
675	679		``` pascal
676	680		with Actions.CurrentAction as TFPWebAction do
677	681		begin
678	682		AResponse.Content := Template.GetContent;
679	683		end;
680	684		Handled := true;
681	685		```
682	686
683	687		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	688
685	689		### A Nivel de Módulo
686	690
687	691		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	692
689	693		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	694
691	695		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	696
693	697		### Usando Plantillas por Separado
694	698
695	699		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	700
697	701		## Usando un objeto html Producer
698	702
699	703		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	704
701	705		``` pascal
702	706		procedure TFPWebModule1.act_get_my_htmlRequest(Sender: TObject; ARequest: TRequest; AResponse: TResponse; var Handled: Boolean);
703	707		begin
704	708		(* pide a HTMLEntityProducer1 el contenido de sus elementos html DOM: *)
705	709		HTMLEntityProducer1.HandleRequest(ARequest, AResponse, Handled);
706	710		Handled := True;
707	711		end;
708	712		```
709	713
710	714		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	715
712	716		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	717
714	718		``` pascal
715	719		procedure TFPWebModule1.HTMLEntityProducer1WriteEntity(Sender: THTMLContentProducer; aWriter: THTMLWriter);
716	720		begin // HTMLEntityProducer has Entity := heHtml
717	721		aWriter.StartHead; // .startHeader;
718	722		aWriter.Meta('','Content-Type','text/html; charset=UTF-8');
719	723		aWriter.title('My web page');
720	724		aWriter.link('stylesheet','stylesheet.css','text/css','screen');
721	725		aWriter.EndHead; // .endHeader;
722	726
723	727		aWriter.Startbody;
724	728		aWriter.StartParagraph;
725	729		aWriter.heading2('Hola, mundo desde adentro §1:');
726	730		aWriter.Text('Esto es texto escrito dentro del párrafo actual.');
727	731		aWriter.EndParagraph;
728	732		aWriter.paragraph('Otro texto dentro de un párrafo "iniciado y terminado" por sí mismo.');
729	733		aWriter.StartP; // .StartParagraph;
730	734		aWriter.tagH2('Hola, mundo desde adentro §2:'); // .heading2;
731	735		aWriter.Text('Aquí está el texto final.');
732	736		aWriter.Image.src := 'logo.png';
733	737		AnotherProducer.WriteContent(aWriter);
734	738		aWriter.EndP; // .EndParagraph;
735	739		// you can use tags and other THtmlCustomElements
736	740		aWriter.tagP([aWriter.bold('Hola'), aWriter.tagQ('Mundo!')]);
737	741		aWriter.Text('<u>Hola,</u><i>mundo!</i>');
738	742		aWriter.Endbody;
739	743
740	744		end;
741	745		```
742	746
743	747		La propiedad TWebAction.ContentProducer permite acoplar un THTTPContentProducer a su acción web expuesta a través de una URI en la red.
744	748
745	749		\[PorHacer: no hay documentación oficial acerca de los componentes "RAD way" de ftweb (html producer, html provider, html adapter, html formatter, etc)\]
746	750
747	751		## Trucos y Consejos
748	752
749	753		### Retornando Distintos Códigos de Respuesta HTTP
750	754
751	755		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	756
753	757		### Redirigir Peticiones a Diferentes URLs
754	758
755	759		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	760
757	761		### Sirviendo Archivos Estáticos (Servidor Web Embebido)
758	762
759	763		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	764
761	765		``` pascal
762	766		RegisterFileLocation('<Location>','<Directory>');
763	767		```
764	768
765	769		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	770
767	771		Puede aprovechar los mime.types completos aquí <http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/conf/mime.types?&view=co>
768	772
769	773		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	774
771	775		``` pascal
772	776		begin
773	777		MimeTypesFile := Application.Location + 'mime.txt';
774	778		```
775	779
776	780		Tenga en cuenta que la ruta por defecto que viene con el proyecto es lib\\\$(TargetCPU)-\$(TargetOS)
777	781
778	782		por ejemplo httpproject\lib\i386-win32\mime.txt
779	783
780	784		### Centralice la Administración de la Configuración y los Módulos
781	785
782	786		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	787
784	788		``` pascal
785	789		unit Brokers;
786	790
787	791		{$mode objfpc}{$H+}
788	792
789	793		interface
790	794
791	795		{ $define cgi}
792	796		{ $define fcgi}
793	797		{$define httpapp}
794	798
795	799		uses
796	800		CustWeb;
797	801
798	802		function GetApp: TCustomWebApplication; inline;
799	803
800	804		implementation
801	805
802	806		uses
803	807		{$ifdef cgi}fpcgi{$endif}
804	808		{$ifdef fcgi}fpfcgi{$endif}
805	809		{$ifdef httpapp}fphttpapp{$endif}
806	810		,webmodule1
807	811		,webmodule2
808	812		;
809	813
810	814		function GetApp: TCustomWebApplication;
811	815		begin
812	816		Result := Application;
813	817		end;
814	818
815	819		initialization
816	820		RegisterHTTPModule('wm1', TWebModule1);
817	821		RegisterHTTPModule('wm2', TWebModule2);
818	822		{$ifndef cgi}
819	823		Application.Port := 2015;
820	824		{$endif}
821	825		Application.Initialize;
822	826		Application.Run;
823	827		end.
824	828		```
825	829
826	830		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	831
828	832		### Terminando Adecuadamente (FastCGI / Servidor Web Embebido)
829	833
830	834		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	835
832	836		### Manejador de Excepción Personalizada
833	837
834	838		\[edición de Mayo 1 de 2020 =\> movido desde un puntero de método a un simple de procedimiento.\]
835	839
836	840		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	841
838	842		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	843
840	844		``` pascal
841	845		Application.OnShowRequestException := @MyExceptionHandler.MyShowRequestException;
842	846		```
843	847
844	848		no olvide .Create() MyExceptionHandler ANTES de asignar arriba u obtendrá un EAccessViolation!
845	849
846	850		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	851
848	852		``` pascal
849	853		Application.OnShowRequestException := @MyShowRequestException;
850	854		```
851	855
852	856		### Codificando Sólo a Mano (Sin Diseñador de Formularios)
853	857
854	858		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	859
856	860		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	861
858	862		``` pascal
859	863		type
860	864		TModuloHolaMundo = class(TFPWebModule)
861	865		constructor CreateNew(AOwner: TComponent; CreateMode: Integer); override;
862	866		procedure Request(Sender: TObject; ARequest: TRequest;
863	867		AResponse: TResponse; var Handled: Boolean);
864	868		end;
865	869
866	870		constructor TModuloHolaMundo.CreateNew(AOwner: TComponent; CreateMode: Integer);
867	871		begin
868	872		inherited CreateNew(AOwner, CreateMode);
869	873		OnRequest := @Request;
870	874		end;
871	875
872	876		procedure TModuloHolaMundo.Request(Sender: TObject; ARequest: TRequest;
873	877		AResponse: TResponse; var Handled: Boolean);
874	878		begin
875	879		AResponse.Content := 'Hola, Mundo!';
876	880		Handled := true;
877	881		end;
878	882		```
879	883
880	884		## Vea También
881	885
882	886		- [Posiblemente el mismo contenido](https://github.com/leledumbo/fpWebTutorial)
883	887		- [Lazarus para la web (tutorial)](https://www.freepascal.org/~michael/articles/#web1)
884	888		- [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	889		- los ejemplos - lea los archivos de texto - en su directorio ...\fpc\x.x.x\source\packages\fcl-web\examples.\
886	890
887	891		![](/wiki-images/c/c0/Cgi-listrecords.png)
888	892
889	893		- 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	894
891	895		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	896		* [Formatos de datos Web en Lazarus/FPC](https://www.freepascal.org/~michael/articles/#webdata)
893	897
894	898		- [Construcción GUI práctica en ExtJS](https://www.freepascal.org/~michael/articles/#extjs1)
895	899		- [Combinando aplicaciones web ExtJS y Pascal: ExtPascal](https://www.freepascal.org/~michael/articles/#extpascal)
896	900
897	901		traducido por edgarrod71@gmail.com
898	902
899	903		---
900	904		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