PRS/WebTemplate - Revision history

Kenric: /* Styling */

2022-08-18T07:33:38Z

Styling

← Older revision		Revision as of 07:33, 18 August 2022
Line 39:		Line 39:
	<code>		<code>
	<style>		<style>
	@(WebDatabaseInterface.GetStylesheet("MAIN"))		@(WebDatabaseInterface.GetStylesheet("MAIN").Style)
	</style>		</style>
	</code><br>		</code><br>

Kenric: /* Slug */

2022-08-18T06:53:27Z

Slug

← Older revision		Revision as of 06:53, 18 August 2022
Line 2:		Line 2:

	== Fields ==		== Fields ==
	=== ~~Slug~~ ===		=== DataModel ===
	The DataModel field is a name of an entity type, such as Equipment or Employee, which specifies the specific data to load for the page template. For example, if you are writing a page which lists employees, it is useful to preload the data necessary - this is done by setting DataModel to "Employee". This field is optional.		The DataModel field is a name of an entity type, such as Equipment or Employee, which specifies the specific data to load for the page template. For example, if you are writing a page which lists employees, it is useful to preload the data necessary - this is done by setting DataModel to "Employee". This field is optional.

Kenric at 06:53, 18 August 2022

2022-08-18T06:53:15Z

← Older revision		Revision as of 06:53, 18 August 2022
Line 1:		Line 1:
	~~== Introduction ==~~

	Web Templates are the manner in which the Web Engine interfaces with a user, written in HTML with C# support using the Razor templating engine. Upon receiving a request from a user, the WebEngine finds the template that is required and then executes it, recompiling if changes have been made.		Web Templates are the manner in which the Web Engine interfaces with a user, written in HTML with C# support using the Razor templating engine. Upon receiving a request from a user, the WebEngine finds the template that is required and then executes it, recompiling if changes have been made.

Kenric at 06:53, 18 August 2022

2022-08-18T06:53:03Z

← Older revision		Revision as of 06:53, 18 August 2022
Line 1:		Line 1:
	== Introduction ==		== Introduction ==

	Web Templates are the manner in which the Web Engine interfaces with a user, written in HTML with C# support using the Razor templating engine. Upon receiving a request from a user		Web Templates are the manner in which the Web Engine interfaces with a user, written in HTML with C# support using the Razor templating engine. Upon receiving a request from a user, the WebEngine finds the template that is required and then executes it, recompiling if changes have been made.

	== Fields ==		== Fields ==
Line 24:		Line 24:
	=== Basics ===		=== Basics ===
	At its base, a template is an HTML file - that is, that one can write a static web page, without the use of C#, and it would display as it would in a browser. Note that this has no means of accessing any resources outside of the page, so any styling with CSS must be embedded.		At its base, a template is an HTML file - that is, that one can write a static web page, without the use of C#, and it would display as it would in a browser. Note that this has no means of accessing any resources outside of the page, so any styling with CSS must be embedded.

			The page is then able to contain embedded C# code, using the Razor syntax. Roughly, one can embed a C# expression by preceding it with an <code>@</code>, e.g. <code>@employee.Name</code>. If the expression is too complex, surround it with parentheses, <code>@(GenericMethod<string>())</code>. To execute blocks of code, use <code>@{ ... }</code>, and for control structures like <code>if</code> and <code>foreach</code>, the <code>@</code> should come before the keyword, e.g. <code>@if(condition){ ... }</code>.

			Within a block of code, one can return to HTML simply by using HTML tags, e.g.
			<pre>
			@if(condition){
			<p>Condition is true</p>
			} else {
			string error = "Condition is false";
			<p>@error</p>
			}
			</pre>

	=== Styling ===		=== Styling ===

Kenric at 06:45, 18 August 2022

2022-08-18T06:45:08Z

@@ Line 10: / Line 10: @@
 The Slug field denotes the name of the page itself, intended to be a short text field which describes the function of the page. Note that it cannot contain any slashes ('/', '\'), and should use only characters which are URL-safe; when in doubt, stick to just numbers and letters.
-The DataModel and slug fields combine to form a path to the page, with the form ''www.domain.com/v1/DataModel/Slug?id=XXXXXXXX-XXXX-XXXX-XXXXXXXX''. If the DataModel field is empty, then the URL is simply ''www.domain.com/v1/Slug''. This allows you to create pages which do not have to be tied to a specific entity.
+The DataModel and slug fields combine to form a path to the page, with the form ''www.domain.com/v1/DataModel/Slug?id=XXXXXXXX-XXXX-XXXX-XXXXXXXX''. If the DataModel field is empty, then the URL is simply ''www.domain.com/v1/Slug''. This allows you to create pages which do not have to be tied to a specific entity. If a page has a DataModel and the id query does not match any page, then a 404 Not Found is returned to the user.
 === Description ===
@@ Line 42: / Line 42: @@
 The second parameter specifies a way to narrow the load of the data, preventing unnecessary data from being loaded. For example, if one only requires the ID and Name fields of an employee, one might call:
 <pre>
-Model.LoadModel(<br>
+Model.LoadModel(
      new string[] {"CompanyInformation", "CompanyLogo", "Employee"},
      new DataModelQueryDef<Employee>(
@@ Line 52: / Line 52: @@
 By default, all columns in the database are loaded, so this is a way to drastically reduce the amount of data loaded.
 (The other two fields, set to <code>null</code>, specify a filter and sort order for the retrieved data.)
 === Partial Templates ===

Kenric: /* Using DataModels */

2022-08-18T06:27:42Z

Using DataModels

← Older revision		Revision as of 06:27, 18 August 2022
Line 40:		Line 40:
	<code>Model.LoadModel(new string[] {"CompanyInformation", "CompanyLogo", "Employee"})</code>.		<code>Model.LoadModel(new string[] {"CompanyInformation", "CompanyLogo", "Employee"})</code>.

	The second parameter specifies a way to narrow the load of the data, preventing unnecessary data from being loaded. For example, if one only requires the ID and Name fields of an employee, one might call:~~<br>~~		The second parameter specifies a way to narrow the load of the data, preventing unnecessary data from being loaded. For example, if one only requires the ID and Name fields of an employee, one might call:
	<~~code~~>		<pre>
	Model.LoadModel(<br>		Model.LoadModel(<br>
	new string[] {"CompanyInformation", "CompanyLogo", "Employee"},		new string[] {"CompanyInformation", "CompanyLogo", "Employee"},
Line 49:		Line 49:
	null)		null)
	)		)
	</~~code~~><br>		</pre><br>
	By default, all columns in the database are loaded, so this is a way to drastically reduce the amount of data loaded.		By default, all columns in the database are loaded, so this is a way to drastically reduce the amount of data loaded.
	(The other two fields, set to <code>null</code>, specify a filter and sort order for the retrieved data.)		(The other two fields, set to <code>null</code>, specify a filter and sort order for the retrieved data.)

	=== Partial Templates ===		=== Partial Templates ===

Kenric: Created page with "== Introduction == Web Templates are the manner in which the Web Engine interfaces with a user, written in HTML with C# support using the Razor templating engine. Upon receiving a request from a user == Fields == === Slug === The DataModel field is a name of an entity type, such as Equipment or Employee, which specifies the specific data to load for the page template. For example, if you are writing a page which lists employees, it is useful to preload the data necessa..."

2022-08-18T06:26:56Z

Created page with "== Introduction == Web Templates are the manner in which the Web Engine interfaces with a user, written in HTML with C# support using the Razor templating engine. Upon receiving a request from a user == Fields == === Slug === The DataModel field is a name of an entity type, such as Equipment or Employee, which specifies the specific data to load for the page template. For example, if you are writing a page which lists employees, it is useful to preload the data necessa..."

New page

== Introduction ==

Web Templates are the manner in which the Web Engine interfaces with a user, written in HTML with C# support using the Razor templating engine. Upon receiving a request from a user

== Fields ==
=== Slug ===
The DataModel field is a name of an entity type, such as Equipment or Employee, which specifies the specific data to load for the page template. For example, if you are writing a page which lists employees, it is useful to preload the data necessary - this is done by setting DataModel to "Employee". This field is optional.

=== Slug ===
The Slug field denotes the name of the page itself, intended to be a short text field which describes the function of the page. Note that it cannot contain any slashes ('/', '\'), and should use only characters which are URL-safe; when in doubt, stick to just numbers and letters.

The DataModel and slug fields combine to form a path to the page, with the form ''www.domain.com/v1/DataModel/Slug?id=XXXXXXXX-XXXX-XXXX-XXXXXXXX''. If the DataModel field is empty, then the URL is simply ''www.domain.com/v1/Slug''. This allows you to create pages which do not have to be tied to a specific entity.

=== Description ===
The Description field is a non-functional field which allows you to add a description to the template - this is not necessary, but can be useful as a reference.

=== Visible ===
The Visible field denotes whether the page is accessibly via a URL - if it is not visible, then a 404 Not Found is returned when trying to access it - it is as if it didn't exist. Use this if you want to disable a page or if the template is only relevant in the context of other templates - see [[#Partial Templates|Partial Templates]]

== Writing a Template ==
To write a template, you should be familiar with HTML, CSS and JavaScript as well as C#, which is used for non-static content.

=== Basics ===
At its base, a template is an HTML file - that is, that one can write a static web page, without the use of C#, and it would display as it would in a browser. Note that this has no means of accessing any resources outside of the page, so any styling with CSS must be embedded.

=== Styling ===
To add a stylesheet, you can create a [[PRS/WebStyle|WebStyle]], which can be loaded with <code>WebDatabaseInterface.GetStylesheet(string code)</code>, which retrieves the content of that stylesheet as raw text. Thus, to use a WebStyle with the code "MAIN", one would put in the <code><head></code> tag:<br>
<code>
<style>
@(WebDatabaseInterface.GetStylesheet("MAIN"))
</style>
</code><br>
This would load that stylesheet into the current web page.<br>If multiple stylesheets need to be loaded, consider using <code>WebDatabaseInterface.GetStylesheets(params string[] stylesheetCodes)</code>, which gets all the stylesheets in request.

=== Using DataModels ===
The Razor engine provides to each template page a parameter called <code>Model</code>, by which data can be retrieved. By default, it contains no data except for a table called "User", which contains the current user. To load the required data for the page, a call to <code>Model.LoadModel(string[] requiredTables, params IDataModelQueryDef[] requiredQueries)</code> must be executed.

The first parameter, <code>requiredTables</code>, specifies which tables should be loaded. By default, <code>LoadModel</code> loads nothing. In general, the CompanyInformation, CompanyLogo and the current entity are useful to load, so a call could look like:<br>
<code>Model.LoadModel(new string[] {"CompanyInformation", "CompanyLogo", "Employee"})</code>.

The second parameter specifies a way to narrow the load of the data, preventing unnecessary data from being loaded. For example, if one only requires the ID and Name fields of an employee, one might call:<br>
<code>
Model.LoadModel(<br>
new string[] {"CompanyInformation", "CompanyLogo", "Employee"},
new DataModelQueryDef<Employee>(
null,
new Columns<Employee>(x => x.ID).Add(x => x.Name),
null)
)
</code><br>
By default, all columns in the database are loaded, so this is a way to drastically reduce the amount of data loaded.
(The other two fields, set to <code>null</code>, specify a filter and sort order for the retrieved data.)

=== Partial Templates ===