Added support for log stored in CMS_STORAGE.

Added support for custom value stored in CMS_STORAGE.
Added optional css classes addition to CMS_BLOCK output.
Refactored storage, to manage node from node module code only (or mostly).

TODO: improved view for a cms node, for now hardcoded.

src/modules/basic_auth/handler/basic_auth_logoff_handler.e

@@ -51,7 +51,7 @@ feature -- HTTP Methods
 			api.logger.put_information (generator + ".do_get Processing basic auth logoff", Void)
 			if attached req.query_parameter ("prompt") as l_prompt then
 				unset_current_user (req)
-				send_access_denied (res)
+				send_access_denied_message (res)
 			else
 				create {GENERIC_VIEW_CMS_RESPONSE} l_page.make (req, res, api)
 				unset_current_user (req)

src/modules/cms_module.e

@@ -36,6 +36,11 @@ feature {CMS_API} -- Module Initialization
 				-- Redefine to process specific module initialization.
 		end
 
+feature {CMS_API} -- Access: API
+
+	module_api: detachable CMS_MODULE_API
+			-- Eventual module api.
+
 feature {CMS_API} -- Module management
 
 	is_installed (api: CMS_API): BOOLEAN

src/modules/node/cms_content_type.e

@@ -0,0 +1,51 @@
+note
+	description: "[
+			Interface defining a CMS content type.
+		]"
+	status: "draft"
+	date: "$Date$"
+	revision: "$Revision$"
+
+deferred class
+	CMS_CONTENT_TYPE
+
+feature -- Access
+
+	name: READABLE_STRING_8
+			-- Internal name.
+		deferred
+		end
+
+	title: READABLE_STRING_32
+			-- Human readable name.
+		deferred
+		end
+
+	description: detachable READABLE_STRING_32
+			-- Optional description
+		deferred
+		end
+
+feature -- Access
+
+	available_formats: LIST [CONTENT_FORMAT]
+			-- Available formats for Current type.
+		deferred
+		end
+
+feature -- Factory
+
+	new_node_with_title (a_title: READABLE_STRING_32; a_partial_node: detachable CMS_NODE): like  new_node
+			-- New node with `a_title' and fill from partial `a_partial_node' if set.
+		deferred
+		end
+
+	new_node (a_partial_node: detachable CMS_NODE): CMS_NODE
+			-- New node based on partial `a_partial_node' if set.
+		deferred
+		end
+
+note
+	copyright: "2011-2015, Javier Velilla, Jocelyn Fiat, Eiffel Software and others"
+	license: "Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)"
+end

src/modules/node/cms_node_api.e

@@ -25,16 +25,30 @@ feature {NONE} -- Implementation
 			-- <Precursor>
 		do
 			Precursor
+			if attached {CMS_STORAGE_SQL_I} storage as l_storage_sql then
+				create {CMS_NODE_STORAGE_SQL} node_storage.make (l_storage_sql)
+			else
+				create {CMS_NODE_STORAGE_NULL} node_storage.make
+			end
 			initialize_content_types
 		end
 
 	initialize_content_types
 			-- Initialize content type system.
+		local
+			ct: CMS_PAGE_CONTENT_TYPE
 		do
 			create content_types.make (1)
-			add_content_type (create {CMS_PAGE_CONTENT_TYPE})
+			create content_type_webform_managers.make (1)
+			create ct
+			add_content_type (ct)
+			add_content_type_webform_manager (create {CMS_PAGE_CONTENT_TYPE_WEBFORM_MANAGER}.make (ct))
 		end
 
+feature {NODE_MODULE} -- Access nodes storage.
+
+	node_storage: CMS_NODE_STORAGE_I
+
 feature -- Content type
 
 	content_types: ARRAYED_LIST [CMS_CONTENT_TYPE]
@@ -59,6 +73,30 @@ feature -- Content type
 			end
 		end
 
+feature -- Content type webform
+
+	content_type_webform_managers: ARRAYED_LIST [CMS_CONTENT_TYPE_WEBFORM_MANAGER]
+			-- Available content types
+
+	add_content_type_webform_manager (a_type: CMS_CONTENT_TYPE_WEBFORM_MANAGER)
+		do
+			content_type_webform_managers.force (a_type)
+		end
+
+	content_type_webform_manager (a_name: READABLE_STRING_GENERAL): detachable CMS_CONTENT_TYPE_WEBFORM_MANAGER
+		do
+			across
+				content_type_webform_managers as ic
+			until
+				Result /= Void
+			loop
+				Result := ic.item
+				if not a_name.is_case_insensitive_equal (Result.name) then
+					Result := Void
+				end
+			end
+		end
+
 feature -- URL
 
 	new_content_path (ct: detachable CMS_CONTENT_TYPE): STRING
@@ -91,19 +129,19 @@ feature -- Access: Node
 
 	nodes_count: INTEGER_64
 		do
-			Result := storage.nodes_count
+			Result := node_storage.nodes_count
 		end
 
 	nodes: LIST [CMS_NODE]
 			-- List of nodes.
 		do
-			Result := storage.nodes
+			Result := node_storage.nodes
 		end
 
 	recent_nodes (a_offset, a_rows: INTEGER): LIST [CMS_NODE]
 			-- List of the `a_rows' most recent nodes starting from  `a_offset'.
 		do
-			Result := storage.recent_nodes (a_offset, a_rows)
+			Result := node_storage.recent_nodes (a_offset, a_rows)
 		end
 
 	node (a_id: INTEGER_64): detachable CMS_NODE
@@ -112,7 +150,7 @@ feature -- Access: Node
 			debug ("refactor_fixme")
 				fixme ("Check preconditions")
 			end
-			Result := full_node (storage.node_by_id (a_id))
+			Result := full_node (node_storage.node_by_id (a_id))
 		end
 
 	full_node (a_node: detachable CMS_NODE): detachable CMS_NODE
@@ -122,7 +160,7 @@ feature -- Access: Node
 			if attached {CMS_PARTIAL_NODE} a_node as l_partial_node then
 				if attached content_type (l_partial_node.content_type) as ct then
 					Result := ct.new_node (l_partial_node)
-					storage.fill_node (Result)
+					node_storage.fill_node (Result)
 				else
 					Result := l_partial_node
 				end
@@ -147,26 +185,32 @@ feature -- Access: Node
 
 feature -- Change: Node
 
+	save_node (a_node: CMS_NODE)
+			-- Save `a_node'.
+		do
+			node_storage.save_node (a_node)
+		end
+
 	new_node (a_node: CMS_NODE)
 			-- Add a new node `a_node'
 		require
 			no_id: not a_node.has_id
 		do
-			storage.new_node (a_node)
+			node_storage.new_node (a_node)
 		end
 
 	delete_node (a_node: CMS_NODE)
 			-- Delete `a_node'.
 		do
 			if a_node.has_id then
-				storage.delete_node (a_node)
+				node_storage.delete_node (a_node)
 			end
 		end
 
 	update_node (a_node: CMS_NODE)
 			-- Update node `a_node' data.
 		do
-			storage.update_node (a_node)
+			node_storage.update_node (a_node)
 		end
 
 --	update_node_title (a_user_id: like {CMS_USER}.id; a_node_id: like {CMS_NODE}.id; a_title: READABLE_STRING_32)
@@ -175,7 +219,7 @@ feature -- Change: Node
 --			debug ("refactor_fixme")
 --				fixme ("Check preconditions")
 --			end
---			storage.update_node_title (a_user_id, a_node_id, a_title)
+--			node_storage.update_node_title (a_user_id, a_node_id, a_title)
 --		end
 
 --	update_node_summary (a_user_id: like {CMS_USER}.id; a_node_id: like {CMS_NODE}.id; a_summary: READABLE_STRING_32)
@@ -184,7 +228,7 @@ feature -- Change: Node
 --			debug ("refactor_fixme")
 --				fixme ("Check preconditions")
 --			end
---			storage.update_node_summary (a_user_id, a_node_id, a_summary)
+--			node_storage.update_node_summary (a_user_id, a_node_id, a_summary)
 --		end
 
 --	update_node_content (a_user_id: like {CMS_USER}.id; a_node_id: like {CMS_NODE}.id; a_content: READABLE_STRING_32)
@@ -193,7 +237,7 @@ feature -- Change: Node
 --			debug ("refactor_fixme")
 --				fixme ("Check preconditions")
 --			end
---			storage.update_node_content (a_user_id, a_node_id, a_content)
+--			node_storage.update_node_content (a_user_id, a_node_id, a_content)
 --		end
 
 

src/modules/node/content_type/cms_page_content_type.e

@@ -9,6 +9,20 @@ class
 
 inherit
 	CMS_CONTENT_TYPE
+		redefine
+			default_create
+		end
+
+feature {NONE} -- Initialization
+
+	default_create
+		do
+			Precursor
+			create {ARRAYED_LIST [like available_formats.item]} available_formats.make (3)
+			available_formats.extend (create {PLAIN_TEXT_CONTENT_FORMAT})
+			available_formats.extend (create {FILTERED_HTML_CONTENT_FORMAT})
+			available_formats.extend (create {FULL_HTML_CONTENT_FORMAT})
+		end
 
 feature -- Access
 
@@ -21,8 +35,23 @@ feature -- Access
 	description: STRING_32 = "Use basic pages for your content, such as an 'About us' page."
 			-- Optional description
 
+feature -- Access
+
+	available_formats: LIST [CONTENT_FORMAT]
+			-- Available formats for Current type.
+
 feature -- Factory
 
+	new_node_with_title (a_title: READABLE_STRING_32; a_partial_node: detachable CMS_NODE): like new_node
+			-- New node with `a_title' and fill from partial `a_partial_node' if set.
+		do
+			create Result.make (a_title)
+			if a_partial_node /= Void then
+				Result.import_node (a_partial_node)
+				Result.set_title (a_title)
+			end
+		end
+
 	new_node (a_partial_node: detachable CMS_NODE): CMS_PAGE
 			-- New node based on partial `a_partial_node', or from none.
 		do

src/modules/node/handler/cms_content_type_webform_manager.e

@@ -0,0 +1,44 @@
+note
+	description: "Summary description for {CMS_CONTENT_TYPE_WEBFORM_MANAGER}."
+	author: ""
+	date: "$Date$"
+	revision: "$Revision$"
+
+deferred class
+	CMS_CONTENT_TYPE_WEBFORM_MANAGER
+
+feature {NONE} -- Initialization
+
+	make (a_type: like content_type)
+		do
+			content_type := a_type
+		end
+
+feature -- Access
+
+	content_type: CMS_CONTENT_TYPE
+			-- Associated content type.
+
+	name: READABLE_STRING_8
+		do
+			Result := content_type.name
+		end
+
+feature -- Forms ...		
+
+	fill_edit_form (response: NODE_RESPONSE; a_form: WSF_FORM; a_node: detachable CMS_NODE)
+		deferred
+		end
+
+	new_node (response: NODE_RESPONSE; a_form_data: WSF_FORM_DATA; a_node: detachable CMS_NODE): CMS_NODE
+		deferred
+--			Result := content_type.new_node (a_node)
+		end
+
+	change_node (response: NODE_RESPONSE; a_form_data: WSF_FORM_DATA; a_node: CMS_NODE)
+		require
+			a_node.has_id
+		deferred
+		end
+
+end

src/modules/node/handler/cms_page_content_type_webform_manager.e

@@ -0,0 +1,160 @@
+note
+	description: "Summary description for {CMS_PAGE_CONTENT_TYPE_WEBFORM_MANAGER}."
+	author: ""
+	date: "$Date$"
+	revision: "$Revision$"
+
+class
+	CMS_PAGE_CONTENT_TYPE_WEBFORM_MANAGER
+
+inherit
+	CMS_CONTENT_TYPE_WEBFORM_MANAGER
+		redefine
+			content_type
+		end
+
+create
+	make
+
+feature -- Access
+
+	content_type: CMS_PAGE_CONTENT_TYPE
+			-- Associated content type.	
+
+feature -- Forms ...		
+
+	fill_edit_form (response: NODE_RESPONSE; f: CMS_FORM; a_node: detachable CMS_NODE)
+		local
+			ti: WSF_FORM_TEXT_INPUT
+			fset: WSF_FORM_FIELD_SET
+			ta: WSF_FORM_TEXTAREA
+			tselect: WSF_FORM_SELECT
+			opt: WSF_FORM_SELECT_OPTION
+		do
+			create ti.make ("title")
+			ti.set_label ("Title")
+			ti.set_size (70)
+			if a_node /= Void then
+				ti.set_text_value (a_node.title)
+			end
+			ti.set_is_required (True)
+			f.extend (ti)
+
+			f.extend_html_text ("<br/>")
+
+			create ta.make ("body")
+			ta.set_rows (10)
+			ta.set_cols (70)
+			if a_node /= Void then
+				ta.set_text_value (a_node.content)
+			end
+--			ta.set_label ("Body")
+			ta.set_description ("This is the main content")
+			ta.set_is_required (False)
+
+			create fset.make
+			fset.set_legend ("Body")
+			fset.extend (ta)
+
+			fset.extend_html_text ("<br/>")
+
+			create tselect.make ("format")
+			tselect.set_label ("Body's format")
+			tselect.set_is_required (True)
+			across
+				 content_type.available_formats as c
+			loop
+				create opt.make (c.item.name, c.item.title)
+				if attached c.item.html_help as f_help then
+					opt.set_description ("<ul>" + f_help + "</ul>")
+				end
+				tselect.add_option (opt)
+			end
+			if a_node /= Void and then attached a_node.format as l_format then
+				tselect.set_text_by_value (l_format)
+			end
+
+			fset.extend (tselect)
+
+			f.extend (fset)
+
+		end
+
+	change_node	(response: NODE_RESPONSE; fd: WSF_FORM_DATA; a_node: like new_node)
+		local
+			b: detachable READABLE_STRING_8
+			f: detachable CONTENT_FORMAT
+		do
+			if attached fd.integer_item ("id") as l_id and then l_id > 0 then
+				check a_node.id = l_id end
+			end
+			if attached fd.string_item ("title") as l_title then
+				a_node.set_title (l_title)
+			end
+
+			if attached fd.string_item ("body") as l_body then
+				b := l_body
+			end
+			if attached fd.string_item ("format") as s_format and then attached response.api.format (s_format) as f_format then
+				f := f_format
+			elseif a_node /= Void and then attached a_node.format as s_format and then attached response.api.format (s_format) as f_format then
+				f := f_format
+			else
+				f := response.api.formats.default_format
+			end
+			if b /= Void then
+				a_node.set_content (b, Void, f.name) -- FIXME: summary
+			end
+		end
+
+	new_node (response: NODE_RESPONSE; fd: WSF_FORM_DATA; a_node: detachable like new_node): CMS_PAGE
+			-- <Precursor>
+		local
+			b: detachable READABLE_STRING_8
+			f: detachable CONTENT_FORMAT
+			l_node: detachable like new_node
+		do
+			l_node := a_node
+			if attached fd.integer_item ("id") as l_id and then l_id > 0 then
+				if l_node /= Void then
+					check l_node.id = l_id end
+				else
+					if attached {like new_node} response.node_api.node (l_id) as n then
+						l_node := n
+					else
+						-- FIXME: Error
+					end
+				end
+			end
+			if attached fd.string_item ("title") as l_title then
+				if l_node = Void then
+					l_node := content_type.new_node (Void)
+					l_node.set_title (l_title)
+				else
+					l_node.set_title (l_title)
+				end
+			else
+				if l_node = Void then
+					l_node := content_type.new_node_with_title ("...", Void)
+				end
+			end
+			l_node.set_author (response.user)
+
+			if attached fd.string_item ("body") as l_body then
+				b := l_body
+			end
+			if attached fd.string_item ("format") as s_format and then attached response.api.format (s_format) as f_format then
+				f := f_format
+			elseif a_node /= Void and then attached a_node.format as s_format and then attached response.api.format (s_format) as f_format then
+				f := f_format
+			else
+				f := response.api.formats.default_format
+			end
+			if b /= Void then
+				l_node.set_content (b, Void, f.name)
+			end
+			Result := l_node
+		end
+
+
+end

src/modules/node/handler/node_form_response.e

@@ -0,0 +1,214 @@
+note
+	description: "Summary description for {NODE_FORM_RESPONSE}."
+	author: ""
+	date: "$Date$"
+	revision: "$Revision$"
+
+class
+	NODE_FORM_RESPONSE
+
+inherit
+	NODE_RESPONSE
+		redefine
+			make,
+			initialize
+		end
+
+create
+	make
+
+feature {NONE} -- Initialization
+
+	make (req: WSF_REQUEST; res: WSF_RESPONSE; a_api: like api; a_node_api: like node_api)
+		do
+			create {WSF_NULL_THEME} wsf_theme.make
+			Precursor (req, res, a_api, a_node_api)
+		end
+
+	initialize
+		do
+			Precursor
+			create {WSF_CMS_THEME} wsf_theme.make (Current, theme)
+		end
+
+	wsf_theme: WSF_THEME
+
+feature -- Execution
+
+	process
+			-- Computed response message.
+		local
+			b: STRING_8
+			f: like edit_form
+			fd: detachable WSF_FORM_DATA
+			nid: INTEGER_64
+		do
+			create b.make_empty
+			nid := node_id_path_parameter (request)
+			if
+				nid > 0 and then
+				attached node_api.node (nid) as l_node
+			then
+				if attached node_api.content_type (l_node.content_type) as l_type then
+					if has_permission ("edit " + l_type.name) then
+						f := edit_form (l_node, url (request.path_info, Void), "edit-" + l_type.name, l_type)
+						if request.is_post_request_method then
+							f.validation_actions.extend (agent edit_form_validate (?, b))
+							f.submit_actions.extend (agent edit_form_submit (?, l_node, l_type, b))
+							f.process (Current)
+							fd := f.last_data
+						end
+
+						set_title ("Edit #" + l_node.id.out)
+
+						add_to_menu (create {CMS_LOCAL_LINK}.make ("View", node_url (l_node)), primary_tabs)
+						add_to_menu (create {CMS_LOCAL_LINK}.make ("Edit", "/node/" + l_node.id.out + "/edit"), primary_tabs)
+
+						f.append_to_html (wsf_theme, b)
+					else
+						b.append ("<h1>Access denied</h1>")
+					end
+				else
+					set_title ("Unknown node")
+				end
+			else
+				set_title ("Create new content ...")
+				b.append ("<ul id=%"content-types%">")
+				across
+					node_api.content_types as c
+				loop
+					if has_permission ("create " + c.item.name) then
+						b.append ("<li>" + link (c.item.name, "/node/add/" + c.item.name, Void))
+						if attached c.item.description as d then
+							b.append ("<div class=%"description%">" + d + "</div>")
+						end
+						b.append ("</li>")
+					end
+				end
+				b.append ("</ul>")
+			end
+			set_main_content (b)
+		end
+
+feature -- Form	
+
+	edit_form_validate (fd: WSF_FORM_DATA; b: STRING)
+		local
+			l_preview: BOOLEAN
+			l_format: detachable CONTENT_FORMAT
+		do
+			l_preview := attached {WSF_STRING} fd.item ("op") as l_op and then l_op.same_string ("Preview")
+			if l_preview then
+				b.append ("<strong>Preview</strong><div class=%"preview%">")
+				if attached fd.string_item ("format") as s_format and then attached api.format (s_format) as f_format then
+					l_format := f_format
+				end
+				if attached fd.string_item ("title") as l_title then
+					b.append ("<strong>Title:</strong><div class=%"title%">" + html_encoded (l_title) + "</div>")
+				end
+				if attached fd.string_item ("body") as l_body then
+					b.append ("<strong>Body:</strong><div class=%"body%">")
+					if l_format /= Void then
+						b.append (l_format.formatted_output (l_body))
+					else
+						b.append (html_encoded (l_body))
+					end
+					b.append ("</div>")
+				end
+				b.append ("</div>")
+			end
+		end
+
+	edit_form_submit (fd: WSF_FORM_DATA; a_node: detachable CMS_NODE; a_type: CMS_CONTENT_TYPE; b: STRING)
+		local
+			l_preview: BOOLEAN
+			l_node: detachable CMS_NODE
+			s: STRING
+		do
+			l_preview := attached {WSF_STRING} fd.item ("op") as l_op and then l_op.same_string ("Preview")
+			if not l_preview then
+				debug ("cms")
+					across
+						fd as c
+					loop
+						b.append ("<li>" +  html_encoded (c.key) + "=")
+						if attached c.item as v then
+							b.append (html_encoded (v.string_representation))
+						end
+						b.append ("</li>")
+					end
+				end
+				if a_node /= Void then
+					l_node := a_node
+					change_node (a_type, fd, a_node)
+					s := "modified"
+				else
+					l_node := new_node (a_type, fd, Void)
+					s := "created"
+				end
+				node_api.save_node (l_node)
+				if attached current_user (request) as u then
+					api.log ("node", "User %"" + user_link (u) + "%" " + s + " node " + link (a_type.name +" #" + l_node.id.out, "/node/" + l_node.id.out , Void), 0, node_local_link (l_node))
+				else
+					api.log ("node", "Anonymous " + s + " node " + a_type.name +" #" + l_node.id.out, 0, node_local_link (l_node))
+				end
+				add_success_message ("Node #" + l_node.id.out + " saved.")
+				set_redirection (node_url (l_node))
+			end
+		end
+
+	edit_form (a_node: detachable CMS_NODE; a_url: READABLE_STRING_8; a_name: STRING; a_type: CMS_CONTENT_TYPE): CMS_FORM
+		local
+			f: CMS_FORM
+			ts: WSF_FORM_SUBMIT_INPUT
+			th: WSF_FORM_HIDDEN_INPUT
+		do
+			create f.make (a_url, a_name)
+
+			create th.make ("node-id")
+			if a_node /= Void then
+				th.set_text_value (a_node.id.out)
+			else
+				th.set_text_value ("0")
+			end
+			f.extend (th)
+
+			fill_edit_form (a_type, f, a_node)
+
+			f.extend_html_text ("<br/>")
+
+			create ts.make ("op")
+			ts.set_default_value ("Save")
+			f.extend (ts)
+
+			create ts.make ("op")
+			ts.set_default_value ("Preview")
+			f.extend (ts)
+
+			Result := f
+		end
+
+	new_node (a_content_type: CMS_CONTENT_TYPE; a_form_data: WSF_FORM_DATA; a_node: detachable CMS_NODE): CMS_NODE
+		do
+			if attached node_api.content_type_webform_manager (a_content_type.name) as wf then
+				Result := wf.new_node (Current, a_form_data, a_node)
+			else
+				Result := a_content_type.new_node (a_node)
+			end
+		end
+
+	change_node (a_content_type: CMS_CONTENT_TYPE; a_form_data: WSF_FORM_DATA; a_node: CMS_NODE)
+		do
+			if attached node_api.content_type_webform_manager (a_content_type.name) as wf then
+				wf.change_node (Current, a_form_data, a_node)
+			end
+		end
+
+	fill_edit_form (a_content_type: CMS_CONTENT_TYPE; a_form: WSF_FORM; a_node: detachable CMS_NODE)
+		do
+			if attached node_api.content_type_webform_manager (a_content_type.name) as wf then
+				wf.fill_edit_form (Current, a_form, a_node)
+			end
+		end
+
+end

src/modules/node/handler/node_handler.e

@@ -1,5 +1,5 @@
 note
-	description: "CMS handler for a node."
+	description: "handler for CMS node in the CMS interface."
 	date: "$Date: 2015-02-13 13:08:13 +0100 (ven., 13 févr. 2015) $"
 	revision: "$Revision: 96616 $"
 
@@ -64,16 +64,34 @@ feature -- HTTP Methods
 			l_page: CMS_RESPONSE
 			s: STRING
 			hdate: HTTP_DATE
+			lnk: CMS_LOCAL_LINK
+			l_node: detachable CMS_NODE
+			l_nid: INTEGER_64
+			edit_response: NODE_FORM_RESPONSE
 		do
-				-- Existing node
-			if attached {WSF_STRING} req.path_parameter ("id") as l_id then
-				if
-					l_id.is_integer and then
-					attached {CMS_NODE} node_api.node (l_id.value.to_integer_64) as l_node
-				then
-						-- FIXME: there is a mix between CMS interface and API interface here.
+			if req.path_info.ends_with_general ("/edit") then
+				create edit_response.make (req, res, api, node_api)
+				edit_response.execute
+			else
+					-- Existing node
+				if attached {WSF_STRING} req.path_parameter ("id") as l_id then
+					if l_id.is_integer then
+						l_nid := l_id.value.to_integer_64
+					end
+				end
+				if l_nid > 0 then
+					l_node := node_api.node (l_nid)
+				end
+				if l_node /= Void then
+							-- FIXME: allow a per content type display here!
 					create {GENERIC_VIEW_CMS_RESPONSE} l_page.make (req, res, api)
 					l_page.add_variable (l_node, "node")
+					create lnk.make ("View", node_api.node_path (l_node))
+					lnk.set_weight (1)
+					l_page.add_to_primary_tabs (lnk)
+					create lnk.make ("Edit", node_api.node_path (l_node) + "/edit")
+					lnk.set_weight (2)
+					l_page.add_to_primary_tabs (lnk)
 
 					create s.make_empty
 					s.append ("<div class=%"info%"> ")
@@ -90,7 +108,12 @@ feature -- HTTP Methods
 					s.append ("</div>")
 					if attached l_node.content as l_content then
 						s.append ("<p class=%"content%">")
-						s.append (api.formats.item (l_node.format).formatted_output (l_content))
+						if attached api.format (l_node.format) as f then
+							s.append (f.formatted_output (l_content))
+						else
+							s.append (api.formats.default_format.formatted_output (l_content))
+						end
+
 						s.append ("</p>")
 					end
 					if attached {CMS_PAGE} l_node as l_node_page then
@@ -103,74 +126,66 @@ feature -- HTTP Methods
 					l_page.set_title (l_node.title)
 					l_page.set_main_content (s)
 					l_page.execute
+				elseif l_nid > 0 then --| i.e: l_node = Void
+					send_not_found (req, res)
 				else
-					do_error (req, res, l_id)
+					send_bad_request (req, res)
+						-- FIXME: should not be accepted
+						-- Factory
+	--				create_new_node (req, res)
 				end
-			else
-					-- Factory
-				new_node (req, res)
 			end
 		end
 
 	do_post (req: WSF_REQUEST; res: WSF_RESPONSE)
 			-- <Precursor>
 		local
-			u_node: CMS_NODE
+			edit_response: NODE_FORM_RESPONSE
 		do
-			to_implement ("Check user permissions!!!")
-			if attached current_user (req) as l_user then
-				if attached {WSF_STRING} req.path_parameter ("id") as l_id then
-					if
-						l_id.is_integer and then
-						attached node_api.node (l_id.value.to_integer_64) as l_node
-					then
-						if attached {WSF_STRING} req.form_parameter ("method") as l_method then
-							if l_method.is_case_insensitive_equal ("DELETE") then
-								do_delete (req, res)
-							elseif l_method.is_case_insensitive_equal ("PUT") then
-								do_put (req, res)
-							else
-								(create {INTERNAL_SERVER_ERROR_CMS_RESPONSE}.make (req, res, api)).execute
+			if req.path_info.ends_with_general ("/edit") then
+				create edit_response.make (req, res, api, node_api)
+				edit_response.execute
+			else
+				to_implement ("Check user permissions!!!")
+				if attached current_user (req) as l_user then
+					if attached {WSF_STRING} req.path_parameter ("id") as l_id then
+						if
+							l_id.is_integer and then
+							attached node_api.node (l_id.value.to_integer_64) as l_node
+						then
+							if attached {WSF_STRING} req.form_parameter ("method") as l_method then
+								if l_method.is_case_insensitive_equal ("DELETE") then
+									do_delete (req, res)
+								elseif l_method.is_case_insensitive_equal ("PUT") then
+									do_put (req, res)
+								else
+									process_node_update (req, res, l_user, l_node)
+										-- Accept this, even if this is not proper usage of POST
+	--								(create {INTERNAL_SERVER_ERROR_CMS_RESPONSE}.make (req, res, api)).execute
+								end
 							end
+						else
+							do_error (req, res, l_id)
 						end
 					else
-						do_error (req, res, l_id)
+						process_node_creation (req, res, l_user)
 					end
 				else
-						-- New node
-						-- FIXME !!!
-					if attached {WSF_STRING} req.form_parameter ("type") as p_type then
-						if attached node_api.content_type (p_type.value) as ct then
-						end
-						create {CMS_PARTIAL_NODE} u_node.make_empty (p_type.url_encoded_value)
-					else
-						create {CMS_PARTIAL_NODE} u_node.make_empty ("")
-					end
-
-					update_node_from_data_form (req, u_node)
-					u_node.set_author (l_user)
-					node_api.new_node (u_node)
-					redirect_to (req.absolute_script_url (""), res)
+					send_access_denied (req, res)
 				end
-			else
-				send_access_denied (res)
 			end
 		end
 
 	do_put (req: WSF_REQUEST; res: WSF_RESPONSE)
 			-- <Precursor>
 		do
-
 			if attached current_user (req) as l_user then
 				if attached {WSF_STRING} req.path_parameter ("id") as l_id then
 					if
 						l_id.is_integer and then
 						attached node_api.node (l_id.value.to_integer_64) as l_node
 					then
-						update_node_from_data_form (req, l_node)
-						l_node.set_author (l_user)
-						node_api.update_node (l_node)
-						redirect_to (req.absolute_script_url (""), res)
+						process_node_update (req, res, l_user, l_node)
 					else
 						do_error (req, res, l_id)
 					end
@@ -178,21 +193,25 @@ feature -- HTTP Methods
 					(create {INTERNAL_SERVER_ERROR_CMS_RESPONSE}.make (req, res, api)).execute
 				end
 			else
-				send_access_denied (res)
+				send_access_denied (req, res)
 			end
 		end
 
 	do_delete (req: WSF_REQUEST; res: WSF_RESPONSE)
 			-- <Precursor>
 		do
-			if attached current_user_name (req) then
+			if attached current_user (req) as l_user then
 				if attached {WSF_STRING} req.path_parameter ("id") as l_id then
 					if
 						l_id.is_integer and then
 						attached node_api.node (l_id.integer_value) as l_node
 					then
-						node_api.delete_node (l_node)
-						res.send (create {CMS_REDIRECTION_RESPONSE_MESSAGE}.make (req.absolute_script_url ("")))
+						if api.user_has_permission (l_user, "delete " + l_node.content_type) then
+							node_api.delete_node (l_node)
+							res.send (create {CMS_REDIRECTION_RESPONSE_MESSAGE}.make (req.absolute_script_url ("")))
+						else
+							send_access_denied (req, res)
+						end
 					else
 						do_error (req, res, l_id)
 					end
@@ -200,20 +219,65 @@ feature -- HTTP Methods
 					(create {INTERNAL_SERVER_ERROR_CMS_RESPONSE}.make (req, res, api)).execute
 				end
 			else
-				send_access_denied (res)
+				send_access_denied (req, res)
+			end
+		end
+
+	process_node_creation (req: WSF_REQUEST; res: WSF_RESPONSE; a_user: CMS_USER)
+		local
+			u_node: CMS_NODE
+		do
+				-- New node
+				-- FIXME !!!
+			if
+				attached {WSF_STRING} req.form_parameter ("type") as p_type and then
+				attached node_api.content_type (p_type.value) as ct  -- should be string 8 value.
+			then
+				if api.user_has_permission (a_user, "create " + ct.name) then
+					u_node := ct.new_node (Void)
+	--						create {CMS_PARTIAL_NODE} u_node.make_empty (p_type.url_encoded_value)
+					update_node_from_data_form (req, u_node)
+					u_node.set_author (a_user)
+					node_api.new_node (u_node)
+					if attached {WSF_STRING} req.item ("destination") as p_destination then
+						redirect_to (req.absolute_script_url (p_destination.url_encoded_value), res)
+					else
+						redirect_to (req.absolute_script_url (""), res)
+					end
+				else
+					send_access_denied (req, res)
+				end
+			else
+				do_error (req, res, Void)
+			end
+		end
+
+	process_node_update (req: WSF_REQUEST; res: WSF_RESPONSE; a_user: CMS_USER; a_node: CMS_NODE)
+		do
+			if api.user_has_permission (a_user, "modify " + a_node.content_type) then
+				update_node_from_data_form (req, a_node)
+				a_node.set_author (a_user)
+				node_api.update_node (a_node)
+				if attached {WSF_STRING} req.item ("destination") as p_destination then
+					redirect_to (req.absolute_script_url (p_destination.url_encoded_value), res)
+				else
+					redirect_to (req.absolute_script_url (""), res)
+				end
+			else
+				send_access_denied (req, res)
 			end
 		end
 
 feature -- Error
 
-	do_error (req: WSF_REQUEST; res: WSF_RESPONSE; a_id: WSF_STRING)
+	do_error (req: WSF_REQUEST; res: WSF_RESPONSE; a_id: detachable WSF_STRING)
 			-- Handling error.
 		local
 			l_page: CMS_RESPONSE
 		do
 			create {GENERIC_VIEW_CMS_RESPONSE} l_page.make (req, res, api)
 			l_page.add_variable (req.absolute_script_url (req.path_info), "request")
-			if a_id.is_integer then
+			if a_id /= Void and then a_id.is_integer then
 					-- resource not found
 				l_page.add_variable ("404", "code")
 				l_page.set_status_code (404)
@@ -227,7 +291,7 @@ feature -- Error
 
 feature {NONE} -- Node
 
-	new_node (req: WSF_REQUEST; res: WSF_RESPONSE)
+	create_new_node (req: WSF_REQUEST; res: WSF_RESPONSE)
 		local
 			l_page: CMS_RESPONSE
 		do
@@ -235,7 +299,7 @@ feature {NONE} -- Node
 				create {GENERIC_VIEW_CMS_RESPONSE} l_page.make (req, res, api)
 				l_page.execute
 			else
-				send_access_denied (res)
+				send_access_denied (req, res)
 			end
 		end
 
@@ -267,4 +331,5 @@ feature -- {NONE} Form data
 			a_node.set_content (l_content, l_summary, l_format)
 		end
 
+
 end

src/modules/node/handler/node_response.e

@@ -0,0 +1,86 @@
+note
+	description: "Summary description for {NODE_RESPONSE}."
+	author: ""
+	date: "$Date$"
+	revision: "$Revision$"
+
+deferred class
+	NODE_RESPONSE
+
+inherit
+	CMS_RESPONSE
+		rename
+			make as make_response
+		redefine
+			custom_prepare
+		end
+
+feature {NONE} -- Initialization
+
+	make (req: WSF_REQUEST; res: WSF_RESPONSE; a_api: like api; a_node_api: like node_api)
+		do
+			node_api := a_node_api
+			make_response (req, res, a_api)
+		end
+
+feature -- Access
+
+	node_api: CMS_NODE_API
+
+feature -- Generation
+
+	custom_prepare (page: CMS_HTML_PAGE)
+		do
+			if attached variables as l_variables then
+				across l_variables as c loop page.register_variable (c.item, c.key) end
+			end
+		end
+
+feature -- Helpers
+
+	node_id_path_parameter (req: WSF_REQUEST): INTEGER_64
+			-- Node id passed as path parameter for request `req'.
+		local
+			s: STRING
+		do
+			if attached {WSF_STRING} req.path_parameter ("id") as p_nid then
+				s := p_nid.value
+				if s.is_integer_64 then
+					Result := s.to_integer_64
+				end
+			end
+		end
+
+feature -- Helpers
+
+	user_local_link (u: CMS_USER): CMS_LINK
+		do
+			create {CMS_LOCAL_LINK} Result.make (u.name, user_url (u))
+		end
+
+	node_local_link (n: CMS_NODE): CMS_LINK
+		do
+			create {CMS_LOCAL_LINK} Result.make (n.title, node_url (n))
+		end
+
+	user_link (u: CMS_USER): like link
+		do
+			Result := link (u.name, "/user/" + u.id.out, Void)
+		end
+
+	node_link (n: CMS_NODE): like link
+		do
+			Result := link (n.title, "/node/" + n.id.out, Void)
+		end
+
+	user_url (u: CMS_USER): like url
+		do
+			Result := url ("/user/" + u.id.out, Void)
+		end
+
+	node_url (n: CMS_NODE): like url
+		do
+			Result := url ("/node/" + n.id.out, Void)
+		end
+
+end

src/modules/node/handler/wsf_cms_theme.e

@@ -0,0 +1,59 @@
+note
+	description: "Summary description for {WSF_CMS_THEME}."
+	author: ""
+	date: "$Date$"
+	revision: "$Revision$"
+
+class
+	WSF_CMS_THEME
+
+inherit
+	WSF_THEME
+
+create
+	make
+
+feature {NONE} -- Initialization
+
+	make (res: CMS_RESPONSE; a_cms_theme: CMS_THEME)
+		do
+			request := res.request
+			cms_theme := a_cms_theme
+			set_response (res)
+		end
+
+feature -- Access
+
+	request: WSF_REQUEST
+
+	response: detachable CMS_RESPONSE
+
+	cms_theme: CMS_THEME
+
+feature -- Element change
+
+	set_response (a_response: CMS_RESPONSE)
+		do
+			response := a_response
+		end
+
+feature -- Core
+
+	site_url: READABLE_STRING_8
+		do
+			if attached response as r then
+				Result := r.site_url
+			else
+				Result := request.absolute_script_url ("")
+			end
+		end
+
+	base_url: detachable READABLE_STRING_8
+			-- Base url if any.
+		do
+			if attached response as r then
+				Result := r.base_url
+			end
+		end
+
+end

src/modules/node/handler/wsf_null_theme.e

@@ -0,0 +1,30 @@
+note
+	description: " Null theme for void-safety purpose."
+	date: "$Date$"
+	revision: "$Revision$"
+
+class
+	WSF_NULL_THEME
+
+inherit
+	WSF_THEME
+
+create
+	make
+
+feature {NONE} -- Initialization
+
+	make
+		do
+		end
+
+feature -- Core
+
+	site_url: STRING = ""
+
+	base_url: detachable READABLE_STRING_8
+			-- Base url if any.
+		do
+		end
+
+end

src/modules/node/node_module.e

@@ -9,11 +9,14 @@ class
 inherit
 
 	CMS_MODULE
+		rename
+			module_api as node_api
 		redefine
 			register_hooks,
 			initialize,
 			is_installed,
-			install
+			install,
+			node_api
 		end
 
 	CMS_HOOK_MENU_SYSTEM_ALTER
@@ -45,31 +48,38 @@ feature {CMS_API} -- Module Initialization
 		local
 			p1,p2: CMS_PAGE
 			ct: CMS_PAGE_CONTENT_TYPE
+			l_node_api: like node_api
 		do
 			Precursor (api)
-			if attached {CMS_NODE_STORAGE_SQL} api.storage as l_sql_storage then
-				l_sql_storage.register_node_storage_extension (create {CMS_NODE_STORAGE_SQL_PAGE_EXTENSION}.make (l_sql_storage))
-				if l_sql_storage.sql_table_items_count ("page_nodes") = 0 then
-						-- Data	
-						-- FIXME: for test purpose, remove later
+			create l_node_api.make (api)
+			node_api := l_node_api
+
+				-- Add support for CMS_PAGE, which requires a storage extension to store the optional "parent" id.
+				-- For now, we only have extension based on SQL statement.
+			if attached {CMS_NODE_STORAGE_SQL} l_node_api.node_storage as l_sql_node_storage then
+				l_sql_node_storage.register_node_storage_extension (create {CMS_NODE_STORAGE_SQL_PAGE_EXTENSION}.make (l_sql_node_storage))
+
+					-- FIXME: the following code is mostly for test purpose/initialization, remove later
+				if l_sql_node_storage.sql_table_items_count ("page_nodes") = 0 then
 					if attached api.user_api.user_by_id (1) as u then
 						create ct
 						p1 := ct.new_node (Void)
 						p1.set_title ("Welcome")
-						p1.set_content ("Welcome, you are using the ROC Eiffel CMS", "Welcome Eiffel ROC user", Void) -- Use default format
+						p1.set_content ("Welcome, you are using the ROC Eiffel CMS", Void, Void) -- Use default format
 						p1.set_author (u)
-						api.storage.save_node (p1)
+						l_sql_node_storage.save_node (p1)
 
 						p2 := ct.new_node (Void)
 						p2.set_title ("A new page example")
-						p2.set_content ("This is the content of a page", "This is a new page", Void) -- Use default format
+						p2.set_content ("This is the content of a page", Void, Void) -- Use default format
 						p2.set_author (u)
 						p2.set_parent (p1)
-						api.storage.save_node (p2)
+						l_sql_node_storage.save_node (p2)
 					end
 				end
 			else
 					-- FIXME: maybe provide a default solution based on file system, when no SQL storage is available.
+					-- IDEA: we could also have generic extension to node system, that handle generic addition field.
 			end
 		end
 
@@ -78,7 +88,7 @@ feature {CMS_API} -- Module management
 	is_installed (api: CMS_API): BOOLEAN
 			-- Is Current module installed?
 		do
-			if attached {CMS_STORAGE_SQL} api.storage as l_sql_storage then
+			if attached {CMS_STORAGE_SQL_I} api.storage as l_sql_storage then
 				Result := l_sql_storage.sql_table_exists ("nodes") and
 					l_sql_storage.sql_table_exists ("page_nodes")
 			end
@@ -87,19 +97,28 @@ feature {CMS_API} -- Module management
 	install (api: CMS_API)
 		do
 				-- Schema
-			if attached {CMS_STORAGE_SQL} api.storage as l_sql_storage then
+			if attached {CMS_STORAGE_SQL_I} api.storage as l_sql_storage then
 				l_sql_storage.sql_execute_file_script (api.setup.layout.path.extended ("scripts").extended (name).appended_with_extension ("sql"))
 			end
 		end
 
+feature {CMS_API} -- Access: API
+
+	node_api: detachable CMS_NODE_API
+			-- <Precursor>
+
 feature -- Access: router
 
 	router (a_api: CMS_API): WSF_ROUTER
 			-- Node router.
 		local
-			l_node_api: CMS_NODE_API
+			l_node_api: like node_api
 		do
-			create l_node_api.make (a_api)
+			l_node_api := node_api
+			if l_node_api = Void then
+				create l_node_api.make (a_api)
+				node_api := l_node_api
+			end
 			create Result.make (2)
 			configure_cms (a_api, l_node_api, Result)
 --			configure_api (a_api, l_node_api, Result)