fpWeb Tutorial: what changed

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

Old	New		Line
1	1		Originally based on: fcl-web tutorial (in PDF) by forum user [Leledumbo](https://forum.lazarus.freepascal.org/index.php?action=profile;u=7523).
2	2
3	3		## Introduction
4	4
5	5		fpWeb is a web application framework shipped by FPC in its default distribution as a part of fcl-web package. The framework itself is built on top of fcl-web features. The framework is built with RAD mind to make a good use of componentization in producing dynamic content. A Lazarus package is provided that can use the framework in a drag n drop manner for its session management and content production. This tutorial will attempt to cover basic functionality of fpWeb, so that one can build common web application with it. Note that this tutorial does NOT attempt to teach HTTP protocol, HTML, CSS, JavaScript or database manipulation as the protocol and client languages should be the prerequisites for every web application programmer and database manipulation does not differ from desktop implementation.
6	6
7	7		## Architecture (PLEASE read)
8	8
9	9		Before starting, it's necessary to know the architecture and application flow to avoid confusion when certain things don't work or work unexpectedly. So please spend some time reading this section.
10	10
11	11		### Application
12	12
13	13		Application here refers to the protocol that your app will implement. fpWeb will happily switch from CGI, FCGI, Apache module to embedded server, and more if fcl-web implements another one in the future. Each application is implemented in its own unit, so to switch from one application to another, with the exception of Apache module, one just needs to change the respective identifier in the uses clause. Currently (as of 3.0.0 / 3.1.1), they are:
14	14
15	15		- fpCGI -\> CGI
16	16		- fpFCGI -\> FastCGI
17	17		- fpApache (requires httpd as well) -\> Apache module
18	18		- fpHttpApp -\> embedded server
19	19		- microhttpapp -\> embedded server using GNU libmicrohttp library.
20	20		- fphttpsys -\> Windows system support for HTTP protocol.
21	21
22	22		Throughout this tutorial, we will use embedded server for the sake of simplicity because you don't have to deal with setting up virtual server and messing up with complicated configuration file and service management. Your app will be a single binary portable web application! Another reason would be there are more than just one web server application out there and each has different way to configure. It would be overkill to cover all of them while their documentation already does the job. Apache module is implemented as a (dynamic) library, while other protocols are normal application. Each application may have specific properties (such as port) available and meaningful only to that application. That's why if you look at fcl-web examples, .lpi / .lpr pairs for each protocol are put in their own directories, only the web modules are shared.
23	23
24	24		### Web Modules
25	25
26	26		![](/wiki-images/5/50/FpWeb-overview.png)
27	27
28	28		fpWeb applications consist of web modules which do the actual content production. A web module can contain web actions that can divide the functionality even more. For instance, an auth web module might have login and logout web actions. While an about web module might not need an action at all and serves just one content. Web module is integrated with fpTemplate that can be used for producing dynamic content from a template file. This is roughly similar to what PHP does, only the gap between logic and presentation is forced rather than suggested. Some say that fpTemplate implements passive view while PHP by default implements an active view design pattern.
29	29
30	30		## Installation
31	31
32	32		The fpWeb package for Lazarus is not installed by default (but it's shipped), to enable fpWeb:
33	33
34	34		1. Open Lazarus and choose Package-\>Install/Uninstall Package
35	35		2. In the Available for installation listbox, look for weblaz and press Install selection. Press Save and rebuild IDE and confirm with Continue
36	36		3. Let the IDE rebuild and restart itself. If everything goes well, you should now have fpWeb tab in the component palette, as shown below:
37	37
38	38
39	39
40	40		![](/wiki-images/5/55/Fpwebtutorial_inst.png)
41	41
42	42		## Specialized modules
43	43
44	44		The TFPWebModule class (used below) is a simple example of a fpWEB module that can be used for all kinds of HTTP requests.
45	45
46	46		However, fpWEB comes with some specialized modules, that have extra support for specialized tasks:
47	47
48	48		- The TSimpleFileModule class in unit fpwebfile.pp can be used to send files. You point it to a directory, and it does the rest.
49	49		- The TFPHTMLModule class in unit fphtml.pp can be used to produce HTML.
50	50		- The TProxyWebModule class in unit fpwebproxy.pp is a ready-made forwarding proxy.
51	51		- The TFPWebProviderDataModule class in unit fpwebdata.pp serves data in JSON format that can be consumed by ExtJS stores.
52	52		- The TSQLDBRestModule class in unit sqldbrestmodule.pp implements a full REST server backed by SQLDB. See more info in [[SQLDBRestBridge]].
53	53		- The TJSONRPCModule class in unit webjsonrpc.pp implements a JSON-RPC service.
54	54		- The TExtDirectModule class in unit fpextdirect.pp implements a Ext.Direct variant of a JSON-RPC service.
55	55
56	56		## Hello, World!
57	57
58	58		Let's create a simple Web Application. As commonly taught when learning programming, "Hello, World!" will be our first app.\
59	59
60	60		1\. Open up Lazarus and choose Project-\>New Project then pick HTTP server Application
61	61
62	62
63	63		![Create new HTTP server application](/wiki-images/5/57/Fpwebtutorial_create_app.png)\
64	64
65	65		2\. Another dialog shall appear for serving static files, port selection and multithreading. Just use default port 8080.
66	66
67	67
68	68		``` pascal
69	69		You may skip the static files serving (go to tips and tricks section if you want to know it more).
70	70		```
71	71
72	72		![](/wiki-images/e/e6/Fpwebtutorial_port_selection.PNG)
73	73
74	74		:IMPORTANT!:
75	75
76	76
77	77		If you choose to use threads on *nix, don't forget to add cthreads as the first unit in the .lpr's uses clause, otherwise a RTE 232 will be generated. When running from console, a message shall appear:
78	78
79	79		``` pascal
80	80		This binary has no thread support compiled in. Recompile the application with a thread-driver in the program uses clause before other units using thread.
81	81		```
82	82
83	83		3\. Since Jan 14, 2017 (or FPC 3.0.4), you may need to open the .lpr and add the following line in the main body if it's not already there:
84	84
85	85
86	86		``` pascal
87	87		Application.LegacyRouting := true;
88	88		```
89	89
90	90		reason will be explained in chapter #Routing.
91	91
92	92		4\. Whatever you choose, pick "OK" and you'll be presented in the default one module fpWeb app.\
93	93		5\. Focus the module and move to Object Inspector. Feel free to rename the module if you wish.\
94	94		6\. Choose Events tab and click the button at the right of the second column of the OnRequest row to create the event handler.
95	95
96	96
97	97		![Creating web module's OnRequest handler in the object inspector](/wiki-images/8/8d/Fpwebtutorial_on_request.png)\
98	98
99	99
100	100		You will be redirected to the source editor with the following code:
101	101
102	102		:
103	103
104	104		``` pascal
105	105		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
106	106		AResponse: TResponse; var Handled: Boolean);
107	107		begin
108	108		\|
109	109		end;
110	110		```
111	111
112	112
113	113		Fill in the event with:
114	114
115	115		:
116	116
117	117		``` pascal
118	118		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
119	119		AResponse: TResponse; var Handled: Boolean);
120	120		begin
121	121		AResponse.Content := 'Hello, World!';
122	122		Handled := true;
123	123		end;
124	124		```
125	125
126	126		7\. Then run your app (or press F9).\
127	127		8\. Open your browser and type:
128	128
129	129
130	130		<http://localhost:8080/>\
131	131
132	132		9\. You should see "Hello, World!" displayed.\
133	133
134	134		If it doesn't, check below:
135	135
136	136		- The framework does a lot of exception handling and the IDE's debugger might catch them and interrupts your app. It's OK to add most of the exceptions to the ignore list so you can concentrate more on your app flow. Keep skipping and continue until no more dialog appears and the browser shows the output.
137	137
138	138		- Handled := true is the way we tell the framework that the request has been handled. Not setting it (or setting it to false) will show error page instead. For now, this doesn't affect the request flow yet, but it will be later on. So keep it that way until the time comes to further make a good use of it.
139	139
140	140		- other track: test without a firewall loaded in RAM (as an application, as a service or deamon, or as both).
141	141
142	142		## Reading GET & POST data
143	143
144	144		A dynamic content is likely to be triggered from user input, either through forms, providing values in the URL, etc. Those data are sent along the request, which is represented in the method as ARequest parameter of type TRequest.
145	145
146	146		### Reading GET
147	147
148	148		GET data is provided as ARequest.QueryFields , which is a TStrings descendant. In short, whatever you usually do with TStrings, is applicable here such as accessing the data in a map style through the Values property.
149	149
150	150		Reusing above code, replace the method body with:
151	151
152	152		``` pascal
153	153		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
154	154		AResponse: TResponse; var Handled: Boolean);
155	155		var
156	156		LName: String;
157	157		begin
158	158		LName := ARequest.QueryFields.Values['Name'];
159	159		if LName = EmptyStr then
160	160		with AResponse.Contents do
161	161		begin
162	162		Add('<form action="' + ARequest.URI + '" method="GET"');
163	163		Add('<label for="name">Please tell me your name:</label>');
164	164		Add('<input type="text" name="name" id="name" />');
165	165		Add('<input type="submit" value="Send" />');
166	166		Add('</form>');
167	167		end
168	168		else
169	169		AResponse.Content := 'Hello, ' + LName + '!';
170	170		Handled := true;
171	171		end;
172	172		```
173	173
174	174		ARequest.URI is just a convenience to refer to the current URI, so even when you change your registered module or action name, this code stays the same.
175	175
176	176		Note that as in Pascal, referring to the data is done case insensitively.
177	177
178	178		Now you can try requesting /, which will display
179	179
180		-	~~` Please tell me your name`~~
	180	+	```text
	181	+	Please tell me your name
	182	+	```
181	183
182	184		and /?name=\<write anything here, e.g.: Bob\>, which will display
183	185
184		-	~~` Hello, Bob!`~~
	186	+	```text
	187	+	Hello, Bob!
	188	+	```
185	189
186	190		### Reading POST
187	191
188	192		POST is actually doesn't differ much from GET, only differs in which property to access. If GET is accessed through ARequest.QueryFields , POST is accessed through ARequest.ContentFields. POST style of previous code is:
189	193
190	194		``` pascal
191	195		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
192	196		AResponse: TResponse; var Handled: Boolean);
193	197		var
194	198		LName: String;
195	199		begin
196	200		LName := ARequest.ContentFields.Values['Name'];
197	201		if LName = EmptyStr then
198	202		with AResponse.Contents do
199	203		begin
200	204		Add('<form action="' + ARequest.URI + '" method="POST"');
201	205		Add('<label for="name">Please tell me your name:</label>');
202	206		Add('<input type="text" name="name" id="name" />');
203	207		Add('<input type="submit" value="Send" />');
204	208		Add('</form>');
205	209		end
206	210		else
207	211		AResponse.Content := 'Hello, ' + LName + '!';
208	212		Handled := true;
209	213		end;
210	214		```
211	215
212	216		### Reading File Uploads
213	217
214	218		One exception is for reading multipart/form-data fields, i.e. files. That one is available in ARequest.Files as a TUploadedFiles instance, which is a TCollection descendant. The following is TUploadedFiles public interface which you can use to access the files:
215	219
216	220		``` pascal
217	221		TUploadedFiles = Class(TCollection)
218	222		...
219	223		public
220	224		Function First: TUploadedFile;
221	225		Function Last: TUploadedFile;
222	226		Function IndexOfFile(AName: String) : Integer;
223	227		Function FileByName(AName: String) : TUploadedFile;
224	228		Function FindFile(AName: String) : TUploadedFile;
225	229		Property Files[Index: Integer] : TUploadedFile read GetFile Write SetFile; default;
226	230		end;
227	231		```
228	232
229	233		Each TUploadedFile itself has several properties:
230	234
231	235		``` pascal
232	236		TUploadedFile = Class(TCollectionItem)
233	237		...
234	238		Public
235	239		Destructor Destroy; override;
236	240		Property FieldName: String Read FFieldName Write FFieldName;
237	241		Property FileName: String Read FFileName Write FFileName;
238	242		Property Stream: TStream Read GetStream;
239	243		Property Size: Int64 Read FSize Write FSize;
240	244		Property ContentType: String Read FContentType Write FContentType;
241	245		Property Disposition: String Read FDisposition Write FDisposition;
242	246		Property LocalFileName: String Read FLocalFileName Write FLocalFileName;
243	247		Property Description: String Read FDescription Write FDescription;
244	248		end;
245	249		```
246	250
247	251		They should be descriptive enough, with the exception of FileName and LocalFileName. FileName is the original file name as uploaded from client, LocalFileName is the file path in the server where the file is temporarily stored. Note the difference in bold terms above.
248	252
249	253		Again, reusing the same request handler:
250	254
251	255		``` pascal
252	256		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
253	257		AResponse: TResponse; var Handled: Boolean);
254	258		var
255	259		n: Integer;
256	260		f: TUploadedFile;
257	261		i: Integer;
258	262		begin
259	263		n := ARequest.Files.Count;
260	264		if n = 0 then
261	265		with AResponse.Contents do
262	266		begin
263	267		Add('<form id="form" action="' + ARequest.URI + '" method="POST" enctype="multipart/form-data">');
264	268		Add('<label for="name">Drag n drop or click to add file:</label>');
265	269		Add('<input type="file" name="input" />');
266	270		Add('<input type="submit" value="Send" />');
267	271		Add('</form>');
268	272		end
269	273		else
270	274		begin
271	275		f := ARequest.Files[0];
272	276		AResponse.Contents.LoadFromStream(f.Stream);
273	277		end;
274	278		Handled := true;
275	279		end;
276	280		```
277	281
278	282		drag n drop a file (preferably text, as it's will be rendered as text) to the input file field (or click the respective button) then click Send button. The file content should be displayed.
279	283
280	284		## Cookies
281	285
282	286		### Setting
283	287
284	288		![The "cookie" concept, invented by Netscape in 1994, to allow the HTTP server to identify all its clients.](cookie_session_Object_Pascal.png "The "cookie" concept, invented by Netscape in 1994, to allow the HTTP server to identify all its clients.")\
285	289		Cookies are browser responsibility to save and keep, therefore server need to send it as part of the response in order to set one. AResponse.Cookies contains a list of cookies to be sent. It's a descendant of TCollection, respectively the contained TCookie is a descendant of TCollectionItem. Therefore, you can use TCollection way of managing items to manipulate it.
286	290
287	291		Here's an example:
288	292
289	293		``` pascal
290	294		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
291	295		AResponse: TResponse; var Handled: Boolean);
292	296		var
293	297		C: TCookie;
294	298		begin
295	299		C := AResponse.Cookies.Add;
296	300		C.Name := 'mycookie';
297	301		C.Value := 'somevalue';
298	302		Handled := true;
299	303		end;
300	304		```
301	305
302	306		You won't see any output in your browser. But if you use some kind of developer tools (Chrome has one built-in), you can see the response header:
303	307
304	308		![](/wiki-images/6/69/Fpwebtutorial_cookie_set.png)
305	309
306	310		Note that cookie has attributes, so Name and Value is not the only two you can set. Browse TCookie interface to see what properties are supported.
307	311
308	312		### Getting
309	313
310	314		Once you give Set-Cookie header above, subsequent request to your site will contain additional header containing the value you ask to set previously:
311	315
312	316		![](/wiki-images/9/93/Fpwebtutorial_cookie_get.png)
313	317
314	318		Fortunately, the way to read it is no different from GET & POST data. The related property is ARequest.CookieFields. To read previously set cookie:
315	319
316	320		``` pascal
317	321		procedure TFPWebModule1.DataModuleRequest(Sender: TObject; ARequest: TRequest;
318	322		AResponse: TResponse; var Handled: Boolean);
319	323		begin
320	324		AResponse.Contents.Add('<p>Cookie get: ' + ARequest.CookieFields.Values['mycookie'] + '</p>');
321	325		Handled := true;
322	326		end;
323	327		```
324	328
325	329		## Sessions
326	330
327	331		TFPWebModule is a descendant of TSessionHTTPModule, so it has session management capability. Session is module based, so each module may choose to use or not to use session management.
328	332
329	333		Session is implemented in abstract manner. By default, no implementation is provided. One sample implementation using .ini files is given in iniwebsession unit. You must have this unit in your project or implement one for session management to work. If you decide to implement one, basically you need to extend and implement abstract methods in TCustomSession and TSessionFactory classes.
330	334
331	335		### Activating
332	336
333	337		To activate session management, set CreateSession property to true. Session will be started prior to request handling. In case of a new session, OnNewSession will be called. Initialize your session variables here.
334	338
335	339		### Session Variables Manipulation
336	340
337	341		Session variables are provided as Session.Variables (nb: the Session object is the equivalent of the \$_SESSION array used in PHP). This is a string to string map like structure, so you can read / write it like:
338	342
339	343		``` pascal
340	344		Session.Variables['myvar'] := myvar; // write
341	345		...
342	346		myvar := Session.Variables['myvar']; // read
343	347		```
344	348
345	349		Setting a variable to empty string does NOT remove it. If you really want to remove a variable, call Session.RemoveVariable instead.
346	350
347	351		### Terminating
348	352
349	353		Call Session.Terminate whenever you want to terminate a session (e.g.: user logout). Session will also automatically expire if the next request comes after Session.TimeOutMinutes since last request. When session terminates, OnSessionExpired will be called. Do whatever cleanup you need there.
350	354
351	355		## Routing
352	356
353	357		Since FPC 3.0.4, a new routing mechanism has been implemented. Instead of maintaining backward compatibility, it is decided that the new routing will be the default. Thus, any old code (or new code depending on old routing) must be ported by adding:
354	358
355	359		``` pascal
356	360		Application.LegacyRouting := true;
357	361		```
358	362
359	363		in the .lpr.
360	364
361	365		### Old Mechanism
362	366
363	367		#### Using Multiple Modules
364	368
365	369		You can have multiple modules in your app. Click "File" menu, then click "New...". A dialog shall appear, select "Web Module" from the treeview.
366	370
367	371		![](/wiki-images/e/e5/Fpwebtutorial_new_module.png)
368	372
369	373		then click OK.
370	374
371	375		With multiple modules exist in your app, you can no longer request just with /. The framework will not be able to magically select which module must serve the response, so there are two ways to state which module you'd like to call:
372	376
373	377		- /\<module name\>
374	378		- /?module=\<module name\>
375	379
376	380		In the 2nd format, you can change "module" (which is the default value) to whatever valid query string key by modifying Application.ModuleVariable.
377	381
378	382		#### Using Actions
379	383
380	384		So far, we've only used web modules with single request handler. This doesn't scale much as your web app gets more and more complex. Moreover, some features might have shared properties and be better logically grouped, e.g.:
381	385
382	386		- Account module
383	387		- Login action
384	388		- Logout action
385	389		- Register action
386	390		- Product module
387	391		- Create action
388	392		- Update action
389	393		- Delete action
390	394		- Details action
391	395
392	396		##### Request Handling Flow
393	397
394	398		Before using action, it is important to know fpWeb request handling flow. Failing to do so might render your action useless because it's always your data module that handles the request. How could that be? Going back a few chapters, remember the Handled := true that we always did before? Now this is where Handled parameter comes into play.
395	399
396	400		Every requests will go through module's OnRequest first, regardless the requested action. Only if it does not set Handled to true, web action's OnRequest is executed.
397	401
398	402		In general, the request flow is:
399	403
400	404		![](/wiki-images/e/ea/Fpwebtutorial_request_flow.png)
401	405
402	406		Notice the "Our Concern" box, that's what we're going to put our attention at.
403	407
404	408		##### Add Actions to Web Modules
405	409
406	410		To add an action, select the web module then go to object inspector. In the properties tab, select Actions and click the button on the second column.
407	411
408	412		![](/wiki-images/9/95/Fpwebtutorial_manage_actions.png)
409	413
410	414		A popup window shall appear where you can add, delete and reorder actions.
411	415
412	416		![](/wiki-images/d/db/Fpwebtutorial_edit_actions.png)
413	417
414	418		Press Add, a new action shall appear in the list. Select it then go to object inspector. It will currently show properties and events of that newly created action. Rename the Name property (this will be the name you write in the URL, so give it a short, simple but descriptive name) as you wish, I will choose "Hello". Move on to events tab, do the same as OnRequest for module, click button on the right of OnRequest row to create the request handler.
415	419
416	420		![](/wiki-images/2/2e/Fpwebtutorial_action_onrequest.png)
417	421
418	422		You will be presented in the same OnRequest interface, but this one handles web action instead of web module. Whatever you can do in web module's OnRequest can be done here as well. Copy the method body from the "Hello, World!" section.
419	423
420	424		Remember to remove Handled := true from the previous web module's OnRequest body (or remove the event completely) for the action to take care of the request handling.
421	425
422	426		Run your project, and fire up your browser. Now, since the request handling is delegated to web action, you can no longer just request /, but you need /\<action name\> or \<Module's ActionVar property\>=\<action name\>. Note that \<Module's ActionVar property\> has a default value of empty string, unlike Application.ModuleVariable which has "module" as the default value. So, by default, you can only use the /\<action name\> form.
423	427
424	428		If you have multiple modules, then you have a variety of options:
425	429
426	430		- /\<module name\>/\<action name\>
427	431		- /\<module name\>?action=\<action name\>
428	432		- /\<action name\>?module=\<module name\>
429	433		- /?module=\<module name\>&action=\<action name\>
430	434
431	435		Note that as soon as a module have at least one action, /\<module or action name\> alone will by default map to /\<action name\>. To change the behavior such that it maps to /\<module name\> by default, set Application.PreferModuleName to true. In case of multiple modules, if no module name given, then the default module will handle the given action. To change the behavior such that module name must be explicitly given, set Application.AllowDefaultModule to false.
432	436
433	437		The following tables summarize what will happen based on the two properties:
434	438
435	439		<thead>
436	440
437	441		</thead>
438	442		<tbody>
439	443
440	444		</tbody>
441	445
442	446		##### Default Action
443	447
444	448		Remember the previous diagram, the "Delegate request handling to actions" is actually not so simple, but if we expand that diagram, the image will be too big to fit. So, here's the diagram of that part:
445	449
446	450		![](/wiki-images/4/44/Fpwebtutorial_request_delegation_flow.png)
447	451
448	452		Two important things from the flow: DefActionWhenUnknown and a default action. The former is a web module's property while the latter corresponds to Default property of an action. In the latter case, in case there are more than two actions having Default property set to true, the the action order (as how it's shown in the manage actions popup window) will be considered to decide which is the default action. The two properties forms what the application should do if no matching action found for a given request.
449	453
450	454		The following tables summarize what will happen based on the two properties:
451	455
452	456		<thead>
453	457
454	458		</thead>
455	459		<tbody>
456	460
457	461		</tbody>
458	462
459	463		<thead>
460	464
461	465		</thead>
462	466		<tbody>
463	467
464	468		</tbody>
465	469
466	470		In case of error response above, a stack trace shall follow, complete with line number information if you build your app with -gl. We'll see later on how to create custom handler for this (stacktrace are no good for production). But for now, make sure you understand the concept of web module and web action, especially the request flow. Play around until you think you're ready for next section.
467	471
468	472		### New Mechanism
469	473
470	474		The new mechanism is extremely flexible and works even without data modules (old mechanism only works with data modules).
471	475
472	476		A dedicated unit for this routing is provided as httproute (add this to uses clause of program / unit where you want to register routes). The unit contains a function HTTPRouter that will return singleton object responsible for application's route management and has RegisterRoute method to register your route.
473	477
474	478		#### Route Syntax
475	479
476	480		The first parameter of HTTPRouter.RegisterRoute is the route that will be matched against incoming request. It can be as simple as *** above, which means 0 or more paths or simply any paths, up to as complex as /api/v1/:resource/* which means REQUEST_URI header should start with /api/v1/** followed by something else that will be bound to variable named resource and finally ended with 0 or more paths. It will match:
477	481
478	482		- /api/v1/products
479	483		- /api/v1/products/1
480	484		- /api/v1/products/1/clone
481	485		- /api/v1/products/something/else/that/is/really/long/and/silly
482	486
483	487		but not:
484	488
485	489		- /api/v1
486	490		- /excuse/me/api/v1/products
487	491
488	492		Basically there are only 3 special characters:
489	493
490	494		- * denoting 0 or more paths
491	495
492	496		-
493	497		param denoting a part
494	498
495	499		- / denoting part separator
496	500
497	501		your route will be composed of these 3 characters, plus everything else that made up a route.
498	502
499	503		#### Registering a Route
500	504
501	505		The 2nd, 3rd or 4th parameter (depending on whether you want to handle specific HTTP method and/or pass additional data to it) of HTTPRouter.RegisterRoute is overloaded with several possibilities:
502	506
503	507		- Callback procedure
504	508
505	509		``` pascal
506	510		TRouteCallback = Procedure(ARequest: TRequest; AResponse);
507	511		```
508	512
509	513		- Callback event
510	514
511	515		``` pascal
512	516		TRouteEvent = Procedure(ARequest: TRequest; AResponse) of object;
513	517		```
514	518
515	519		- Object satisfying a (CORBA) interface
516	520
517	521		``` pascal
518	522		IRouteInterface = Interface ['{10115353-10BA-4B00-FDA5-80B69AC4CAD0}']
519	523		Procedure HandleRequest(ARequest: TRequest; AResponse: TResponse);
520	524		end;
521	525		```
522	526
523	527		- Object extending abstract router class
524	528
525	529		``` pascal
526	530		TRouteObject = Class(TObject, IRouteInterface)
527	531		Public
528	532		Procedure HandleRequest(ARequest: TRequest; AResponse: TResponse); virtual; abstract;
529	533		end;
530	534
531	535		TRouteObjectClass = Class of TRouteObject;
532	536		```
533	537
534	538		By default, if 2nd parameter is not a TRouteMethod, then all HTTP methods will match. Use one of rmUnknown, rmAll, rmGet, rmPost, rmPut, rmDelete, rmOptions, rmHead, rmTrace to match only a specific HTTP method.
535	539
536	540		Registration order matters. If there are two or more routes matching the current request, the earlier registered one will handle it.
537	541
538	542		In this new mechanism, standalone Hello, World! program can be as simple as:
539	543
540	544		``` pascal
541	545		uses
542	546		fphttpapp, httpdefs, httproute;
543	547		procedure DoHello(ARequest:TRequest; AResponse : TResponse);
544	548		begin
545	549		AResponse.Content:='<html><body><h1>Hello,World!</h1></body></html>'
546	550		end;
547	551
548	552		begin
549	553		HTTPRouter.RegisterRoute('*', @DoHello);
550	554		Application.Port := 9000;
551	555		Application.Initialize;
552	556		Application.Run;
553	557		end.
554	558		```
555	559
556	560		#### Webserver example
557	561
558	562		This is an example of a simple, cross-platform, multi-threaded web server.
559	563
560	564		``` pascal
561	565		program webserver;
562	566
563	567		{$mode objfpc}{$H+}
564	568
565	569		uses
566	570		{$ifdef UNIX}
567	571		cthreads, cmem,
568	572		{$endif}
569	573		fphttpapp, httpdefs, httproute;
570	574
571	575		procedure route1(aReq: TRequest; aResp: TResponse);
572	576		begin
573	577		aResp.content:='<html><body><h1>Route 1 The Default</h1></body></html>'
574	578		end;
575	579
576	580		procedure route2(aReq: TRequest; aResp: TResponse);
577	581		begin
578	582		aResp.content:='<html><body><h1>Route 2</h1></body></html>'
579	583		end;
580	584
581	585		begin
582	586		HTTPRouter.registerRoute('/', @route1, true);
583	587		HTTPRouter.registerRoute('/route2', @route2);
584	588		Application.port := 8080;
585	589		Application.threaded := true;
586	590		Application.initialize;
587	591		Application.run;
588	592		end.
589	593		```
590	594
591	595		To open "Route 1" type into your browser the following URL: <http://127.0.0.1:8080>
592	596
593	597		To open "Route 2" type into your browser the following URL: <http://127.0.0.1:8080/route2>
594	598
595	599		## Using Templates
596	600
597	601		fpWeb has integrated support for FPTemplate, Free Pascal's generic templating engine. It doesn't have to be used from web application context, but with integrated support things will be easier a bit. At least the memory management can be ignored as the module will take care of it.
598	602
599	603		There are two levels where one can use templates at: action and module. The full RAD support is incomplete, so you need to go down to hand coding at some points.
600	604
601	605		There are two modes of operation: non-parameterized and parameterized. The active mode is controlled by AllowTagParams property, which should be obvious enough what value refers to what mode.
602	606
603	607		Template string can be given from a file through FileName property or a direct string through Template property. Template.Template, I know it sounds weird :) If both are filled then FileName will take precedence.
604	608
605	609		The two properties: StartDelimiter and EndDelimiter define how the engine should recognize a template tag. For instance, if you have:
606	610
607	611		- StartDelimiter = '{+'
608	612		- EndDelimiter = '+}'
609	613
610	614		then a string '{+title+}' defines a template tag named 'title'. Note that spaces are significant, so '{+ title +}' defines a template tag named ' title ' instead of just 'title'.
611	615
612	616		Special for parameterized mode, additional three properties: ParamStartDelimiter, ParamEndDelimiter and ParamValueSeparator defines how the engine should recognize a template tag parameter. For instance, if you have:
613	617
614	618		- ParamStartDelimiter = '\[-'
615	619		- ParamEndDelimiter = '-\]'
616	620		- ParamValueSeparator = '='
617	621
618	622		then a string '{+data \[-p=v-\]\[-a=b-\] +}' defines a template tag named 'data' with parameter 'p' of value 'v' and parameter 'a' of value 'b'. This can be used to pass template level parameter such as expected date format, header-row-footer for customizable output presentation, name of file, etc. you decide.
619	623
620	624		As a consequence of different way of operation, the core event where the template works is different, too. Non-parameterized will use OnGetParam while the parameterized will use OnReplaceTag. The two has of course different interface:
621	625
622	626		``` pascal
623	627		Type
624	628		// OnGetParam: for simple template tag support only (ex: {Name})
625	629		TGetParamEvent = Procedure(
626	630		Sender: TObject;
627	631		Const ParamName: String;
628	632		Out AValue: String
629	633		) Of Object;
630	634		// OnReplaceTag: for tags with parameters support
631	635		TReplaceTagEvent = Procedure(
632	636		Sender: TObject;
633	637		Const TagString: String;
634	638		TagParams: TStringList;
635	639		Out ReplaceText: String
636	640		) Of Object;
637	641		```
638	642
639	643		In OnGetParam, you check for ParamName, then assign AValue accordingly. i.e., if you want tag 'title' to be replaced by 'My App', then fill in the method with:
640	644
641	645		``` pascal
642	646		// use Trim() if you want the spaces around tag to be insignificant
643	647		case Trim(ParamName) of
644	648		'title': AValue := 'My App';
645	649		else
646	650		AValue := 'UNKNOWN';
647	651		end;
648	652		```
649	653
650	654		In OnReplaceTag, you check for TagString and optionally TagParams, then assign ReplaceText accordingly. i.e., if you want tag 'datetime' to be replaced by current time with parameter 'datetimeformat' to specify how the date and time should be formatted, then fill in the method like this:
651	655
652	656		``` pascal
653	657		// use Trim() if you want the spaces around tag to be insignificant
654	658		case Trim(TagString) of
655	659		'datetime': AValue := FormatDateTime(TagParams.Values['datetimeformat'],Now);
656	660		else
657	661		AValue := 'UNKNOWN';
658	662		end;
659	663		```
660	664
661	665		### At Action Level
662	666
663	667		Create/select an action, then go to object inspector. You will see a subcomponent property named Template. This template is a normal TFPTemplate instance. Expand it and fill in the properties as explained above. Now go to Events tab, again expand Template, you will see the two events. Fill the one based on your value of AllowTagParams property.
664	668
665	669		NOTE: If your Lazarus cannot autocomplete the event, try writing the name manually in the edit box then click the ... button. This is a bug in present Lazarus which may be fixed in the future.
666	670
667	671		At this level, template with a content is not automatically set as request handler. It might change in the future, but let's deal with its current state. Fill in OnRequest event of the action, then fill it with:
668	672
669	673		``` pascal
670	674		with Actions.CurrentAction as TFPWebAction do
671	675		begin
672	676		AResponse.Content := Template.GetContent;
673	677		end;
674	678		Handled := true;
675	679		```
676	680
677	681		The cast is required since CurrentAction is of type TCustomWebAction instead of TFPWebAction. Without it, we can't access the Template property.
678	682
679	683		### At Module Level
680	684
681	685		At module level, you currently have to do it by hand coding since no RAD support is implemented. The linked property is ModuleTemplate . This is however not a regular TFPTemplate instance, but special TFPWebTemplate class that's a descendant of it.
682	686
683	687		The idea here is to have module provide a layout while the actions provide content, with the ability to provide additional variables. It's therefore a good idea to keep AllowTagParams as is and assign OnGetParam event of the module only. Do NOT assign OnGetParam of ModuleTemplate as it will never be called.
684	688
685	689		A template tag named 'content' will be replaced automatically by what content produced by action, everything else is either replaced from internal template variables or from OnGetParam.
686	690
687	691		### Using Separated Template
688	692
689	693		Despite the somewhat incomplete integration, nothing stops you from using fpTemplate (or any other templating solutions) manually, outside from the integrated support. This could even be better in some cases since it's modular.
690	694
691	695		## Using an html Producer object
692	696
693	697		Assuming that there is a TWebAction named act_get_my_html, you must ask to write in AResponse, the return of an internal bytes stream: when answering with html Producer objects solution, we must use the methods of the writer. It manages a memory stream for a purpose of rapidity. No string type here, like with the above fpTemplate solution which uses text \\ string processing as in the regular Php way. The Producer writes in AResponse with a recursive " foreach " iteration, that traverses the polymorphic objects HTML Dom tree, composed with the hierarchy THtmlCustomElement = Class(TDOMElement) Classes (see unit htmlelements.pp). So, the AResponse is written by the parameter aWriter, with the following call:
694	698
695	699		``` pascal
696	700		procedure TFPWebModule1.act_get_my_htmlRequest(Sender: TObject; ARequest: TRequest; AResponse: TResponse; var Handled: Boolean);
697	701		begin
698	702		(* ask HTMLEntityProducer1 for the content of its html DOM elements: *)
699	703		HTMLEntityProducer1.HandleRequest(ARequest, AResponse, Handled);
700	704		Handled := True;
701	705		end;
702	706		```
703	707
704	708		Said again, it's the job of the Producer to convert its internal memory stream into text in the response object: that's how this pattern was designed, although there is a text-html rendering method named ProduceContent for debugging purposes only. You can override this method if you are writing or debugging a Producer component.
705	709
706	710		Here is an example, always with an html Producer object, allowing to create a web application in the "RAD way", i.e. with the drag-drop of the HTMLEntityProducer component from the pallet:
707	711
708	712		``` pascal
709	713		procedure TFPWebModule1.HTMLEntityProducer1WriteEntity(Sender: THTMLContentProducer; aWriter: THTMLWriter);
710	714		begin
711	715
712	716		aWriter.startHeader;
713	717		aWriter.Meta('','Content-Type','text/html; charset=UTF-8');
714	718		aWriter.title('My web page');
715	719		aWriter.link('stylesheet','stylesheet.css','text/css','screen');
716	720		aWriter.EndHeader;
717	721
718	722		aWriter.Startbody;
719	723		aWriter.Startparagraph;
720	724		aWriter.heading2('Hello, world from inside §1:');
721	725		aWriter.Text('Here is text written inside the current paragraph.');
722	726		aWriter.Endparagraph;
723	727		aWriter.paragraph('This is another text written inside a self "started and ended" paragraph.');
724	728		aWriter.Startparagraph;
725	729		aWriter.heading2('Hello, world from inside §2:');
726	730		aWriter.Text('Here is the final text.');
727	731		aWriter.Image.src := 'logo.png';
728	732		AnotherProducer.WriteContent(aWriter);
729	733		aWriter.Endparagraph;
730	734		aWriter.Endbody;
731	735
732	736		end;
733	737		```
734	738
735	739		The TWebAction.ContentProducer property allows to couple a THTTPContentProducer to its web action exposed via a URI on the net.
736	740
737	741		\[ToDo: there is no official documentation about the components "RAD way" of fpWeb (html producer, html provider, html adapter, html formatter, etc)\]
738	742
739	743		## Tips and Tricks
740	744
741	745		### Returning Different HTTP Response Code
742	746
743	747		By default, fpWeb will return HTTP 200 OK to indicate successful request handling. This surely is not always the case, as user input might not be as what we expected. To do so, set AResponse.Code in your request handler to the code you want to return.
744	748
745	749		### Redirect Request to Different URL
746	750
747	751		A common flow after a successful login is to redirect user to his account page. This can be done by calling AResponse.SendRedirect in your request handler, supplying the URL to redirect request to.
748	752
749	753		### Serving Static Files (Embedded Web Server)
750	754
751	755		Remember the dialog in the #Hello, World! section after you select HTTP server Application? If you tick "Register location to serve files from" you can fill "Location" (the URI segment, must not contain any slashes) and "Directory" (physical directory in your computer, must exist at runtime) and the wizard will simply add:
752	756
753	757		``` pascal
754	758		RegisterFileLocation('<Location>','<Directory>');
755	759		```
756	760
757	761		to the beginning of your .lpr and add the unit fpwebfile to the uses clause. You can actually do this by hand anytime and also register multiple times for different locations / directories. After this you can request /\<Location\>/\<any filename under Directory\> and it will be served automatically. Note that the mimetype of the file is determined by fpmimetypes. Call MimeTypes.LoadFromFile with your mime.types file in order to give correct mimetype based on its extension. Otherwise, the file will always be served as application/octet-stream which means the browser will download it instead of interpreting it (especially important for JavaScript and CSS files).
758	762
759	763		You can grab a complete mime.types here <http://svn.apache.org/viewvc/httpd/httpd/trunk/docs/conf/mime.types?&view=co>
760	764
761	765		In Lazarus 2.0.6 or newer you must add at the top of your program the full path of the mime.types file
762	766
763	767		``` pascal
764	768		begin
765	769		MimeTypesFile := Application.Location + 'mime.txt';
766	770		```
767	771
768	772		Take into consideration that the default path coming with the project is lib\\\$(TargetCPU)-\$(TargetOS)
769	773
770	774		For example httpproject\lib\i386-win32\mime.txt
771	775
772	776		### Centralize Management of Configuration and Modules
773	777
774	778		By default, the program file (.lpr) is the one that contains protocol unit. This limits the ability to use Application object from other contexts such as from web modules. Fortunately, it's not difficult to refactor to have what we want. We remove RegisterHTTPModule calls from web modules' units and left out the .lpr to empty main block with single unit identifier in the uses clause, we name it: brokers. The unit contains:
775	779
776	780		``` pascal
777	781		unit Brokers;
778	782
779	783		{$mode objfpc}{$H+}
780	784
781	785		interface
782	786
783	787		{ $define cgi}
784	788		{ $define fcgi}
785	789		{$define httpapp}
786	790
787	791		uses
788	792		CustWeb;
789	793
790	794		function GetApp: TCustomWebApplication; inline;
791	795
792	796		implementation
793	797
794	798		uses
795	799		{$ifdef cgi}fpcgi{$endif}
796	800		{$ifdef fcgi}fpfcgi{$endif}
797	801		{$ifdef httpapp}fphttpapp{$endif}
798	802		,webmodule1
799	803		,webmodule2
800	804		;
801	805
802	806		function GetApp: TCustomWebApplication;
803	807		begin
804	808		Result := Application;
805	809		end;
806	810
807	811		initialization
808	812		RegisterHTTPModule('wm1', TWebModule1);
809	813		RegisterHTTPModule('wm2', TWebModule2);
810	814		{$ifndef cgi}
811	815		Application.Port := 2015;
812	816		{$endif}
813	817		Application.Initialize;
814	818		Application.Run;
815	819		end.
816	820		```
817	821
818	822		This way, we can control over web module registration and also provide an API to get Application object (casted as TCustomWebApplication), while still easily switch between protocol implementations, in a single place.
819	823
820	824		### Terminating Gracefully (FastCGI / Embedded Web Server)
821	825
822	826		Instead of Ctrl+C-ing your app, there is a way for your app to terminate gracefully, doing whatever cleanup it needs, by calling Application.Terminate. You might need to use previous trick to easily access the Application object. A common implementation is to provide a specific password protected module / action that calls the Terminate method. You may choose whatever way you want, though.
823	827
824	828		### Custom Exception Handler
825	829
826	830		\[edit the May 1, 2020 =\> moved from a method pointer to a simple procedure.\]
827	831
828	832		To override the default exception handler, which prints stacktrace whenever an exception is raised (i.e.: on HTTP 404 or 500), and thus not good for production, you must assign Application.OnShowRequestException.
829	833
830	834		This is a method so you will need to provide your procedure that implements the method and assign it by using the object. i.e.: if you have MyExceptionHandler as an object of TMyExceptionHandler which has MyShowRequestException method, you can assign it by:
831	835
832	836		``` pascal
833	837		Application.OnShowRequestException := @MyExceptionHandler.MyShowRequestException;
834	838		```
835	839
836	840		don't forget to .Create() MyExceptionHandler BEFORE assigning above or you will get an EAccessViolation!
837	841
838	842		You must provide your global procedure that implements your own exception handler (in production, it is advisable to replace the call stack by an HTTP status code and its explanation). Then, you can override the default exception handler, by assigning it like this:
839	843
840	844		``` pascal
841	845		Application.OnShowRequestException := @MyShowRequestException;
842	846		```
843	847
844	848		### Pure Hand Coding (No Form Designer Required)
845	849
846	850		It's not a must to use Lazarus' form designer to write an fpWeb application. You can use pure hand coding technique to write it. The secret lies in the 3rd parameter of RegisterHTTPModule : SkipStreaming. When this parameter is set to true, fpWeb will not search for .lfm resource. Therefore everything must be manually handled: property settings, event handlers, action registration, etc.
847	851
848	852		Note that it's logical to do what's usually done through object inspector in an overriden constructor. Inside it, call the inherited constructor supplying both AOwner and CreateMode as parameters. After that you can set properties, assign event handlers, etc. Example:
849	853
850	854		``` pascal
851	855		type
852	856		THelloWorldModule = class(TFPWebModule)
853	857		constructor CreateNew(AOwner: TComponent; CreateMode: Integer); override;
854	858		procedure Request(Sender: TObject; ARequest: TRequest;
855	859		AResponse: TResponse; var Handled: Boolean);
856	860		end;
857	861
858	862		constructor THelloWorldModule.CreateNew(AOwner: TComponent; CreateMode: Integer);
859	863		begin
860	864		inherited CreateNew(AOwner,CreateMode);
861	865		OnRequest := @Request;
862	866		end;
863	867
864	868		procedure THelloWorldModule.Request(Sender: TObject; ARequest: TRequest;
865	869		AResponse: TResponse; var Handled: Boolean);
866	870		begin
867	871		AResponse.Content := 'Hello, World!';
868	872		Handled := true;
869	873		end;
870	874		```
871	875
872	876		## See also
873	877
874	878		- [Possibly same content](https://github.com/leledumbo/fpWebTutorial)
875	879		- [Lazarus for the web (tutorial)](https://www.freepascal.org/~michael/articles/#web1)
876	880		- [Lazarus for the web: Sessions and Templates (tutorial)](https://www.freepascal.org/~michael/articles/#web2) This article explains a TSQLDBSession Class that manages a SQL connection, that inherits from a web session (in order to manage the histories of web session variables, within a connection-session to a database having row-locking capabilities).
877	881		- the examples - read the text files - in your directory ...\fpc\x.x.x\source\packages\fcl-web\examples.\
878	882
879	883		![](/wiki-images/c/c0/Cgi-listrecords.png)
880	884
881	885		- XML or JSON, on ExtJS: if you want to use a more or less complex engine that is very "accomplished" regarding the rendering aspect of Javascript objects on the browser side, in addition to their functionalities (like ExtJS, for example, to display a db-aware grid, dynamic graphics, etc), this kind of solution very very often expects an XML or a JSON file. There are Adapter and Formatter classes (e.g. the classes TExtJSXMLWebdataInputAdaptor, TExtJSJSONDataFormatter).
882	886
883	887		Overall, the Adapter classes adapt the nodes of an incoming jSon or XML to a mapping of their TField database fields. And Formatter classes are mappers of each TField of a record to its node in jSon or XML format, before sending it out towards the browser.\
884	888		* [Web data formats in Lazarus/FPC](https://www.freepascal.org/~michael/articles/#webdata)
885	889
886	890		- [Practical GUI construction in ExtJS](https://www.freepascal.org/~michael/articles/#extjs1)
887	891		- [Mixing ExtJS webapplications and Pascal: ExtPascal](https://www.freepascal.org/~michael/articles/#extpascal)
888	892
889	893		---
890	894		From the Free Pascal wiki, page "fpWeb Tutorial", as it stood on 2023-03-17 after a change by Trev, 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