fpWeb Tutorial/es: what changed

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