backup/ROC
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor directory structrue

Browse Source
This commit is contained in:
jvelilla
2014-11-13 11:57:36 -03:00
parent 8ab4343d5b
commit d963fd218b
154 changed files with 12 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

199
library/src/service/cms_api.e Normal file
View File

@@ -0,0 +1,199 @@
note
description: "API for a CMS"
date: "$Date$"
revision: "$Revision$"
class
CMS_API
inherit
SHARED_ERROR
REFACTORING_HELPER
create
make
feature -- Initialize
make (a_setup: CMS_SETUP)
-- Create the API service with a setup `a_setup'
do
setup := a_setup
create error_handler.make
initialize
set_successful
ensure
setup_set: setup = a_setup
error_handler_set: not error_handler.has_error
end
setup: CMS_SETUP
-- CMS setup.
initialize
-- Initialize the persitent layer.
local
l_database: DATABASE_CONNECTION
retried: BOOLEAN
l_message: STRING
do
if not retried then
to_implement ("Refactor database setup")
if attached (create {JSON_CONFIGURATION}).new_database_configuration (setup.layout.application_config_path) as l_database_config then
create {DATABASE_CONNECTION_MYSQL} l_database.login_with_connection_string (l_database_config.connection_string)
create {CMS_STORAGE_MYSQL} storage.make (l_database)
else
create {DATABASE_CONNECTION_NULL} l_database.make_common
create {CMS_STORAGE_NULL} storage
end
else
to_implement ("Workaround code, persistence layer does not implement yet this kind of error handling.")
-- error hanling.
create {DATABASE_CONNECTION_NULL} l_database.make_common
create {CMS_STORAGE_NULL} storage
create l_message.make (1024)
if attached ((create {EXCEPTION_MANAGER}).last_exception) as l_exception then
if attached l_exception.description as l_description then
l_message.append (l_description.as_string_32)
l_message.append ("%N%N")
elseif attached l_exception.trace as l_trace then
l_message.append (l_trace)
l_message.append ("%N%N")
else
l_message.append (l_exception.out)
l_message.append ("%N%N")
end
else
l_message.append ("The application crash without available information")
l_message.append ("%N%N")
end
error_handler.add_custom_error (0, " Database Connection ", l_message)
end
rescue
retried := True
retry
end
feature -- Access
error_handler: ERROR_HANDLER
-- Error handler.
feature -- Status Report
is_valid_credential (a_auth_login, a_auth_password: READABLE_STRING_32): BOOLEAN
-- Is the credentials `a_auth_login' and `a_auth_password' valid?
do
Result := storage.is_valid_credential (a_auth_login, a_auth_password)
end
feature -- Access: Node
nodes: LIST[CMS_NODE]
-- List of nodes.
do
debug ("refactor_fixme")
fixme ("Implementation")
end
Result := storage.recent_nodes (0, 10)
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)
end
node (a_id: INTEGER_64): detachable CMS_NODE
-- Node by ID.
do
debug ("refactor_fixme")
fixme ("Check preconditions")
end
Result := storage.node (a_id)
end
feature -- Change: Node
new_node (a_node: CMS_NODE)
-- Add a new node `a_node'
do
storage.save_node (a_node)
end
delete_node (a_id: INTEGER_64)
-- Delete a node identified by `a_id', if any.
do
storage.delete_node (a_id)
end
update_node (a_id: like {CMS_USER}.id; a_node: CMS_NODE)
-- Update node by id `a_id' with `a_node' data.
do
storage.update_node (a_id,a_node)
end
update_node_title (a_id: like {CMS_USER}.id; a_node_id: like {CMS_NODE}.id; a_title: READABLE_STRING_32)
-- Update node title, with user identified by `a_id', with node id `a_node_id' and a new title `a_title'.
do
debug ("refactor_fixme")
fixme ("Check preconditions")
end
storage.update_node_title (a_id,a_node_id,a_title)
end
update_node_summary (a_id: like {CMS_USER}.id; a_node_id: like {CMS_NODE}.id; a_summary: READABLE_STRING_32)
-- Update node summary, with user identified by `a_id', with node id `a_node_id' and a new summary `a_summary'.
do
debug ("refactor_fixme")
fixme ("Check preconditions")
end
storage.update_node_summary (a_id,a_node_id, a_summary)
end
update_node_content (a_id: like {CMS_USER}.id; a_node_id: like {CMS_NODE}.id; a_content: READABLE_STRING_32)
-- Update node content, with user identified by `a_id', with node id `a_node_id' and a new content `a_content'.
do
debug ("refactor_fixme")
fixme ("Check preconditions")
end
storage.update_node_content (a_id,a_node_id, a_content)
end
feature -- Access: User
user_by_name (a_username: READABLE_STRING_32): detachable CMS_USER
-- User by name `a_user_name', if any.
do
Result := storage.user_by_name (a_username)
end
feature -- Change User
new_user (a_user: CMS_USER)
-- Add a new user `a_user'.
do
if
attached a_user.password as l_password and then
attached a_user.email as l_email
then
storage.save_user (a_user)
else
debug ("refactor_fixme")
fixme ("Add error")
end
end
end
feature {NONE} -- Implemenataion
storage: CMS_STORAGE
-- Persistence storage.
end

17
library/src/service/cms_api_options.e Normal file
View File

@@ -0,0 +1,17 @@
note
description: "Summary description for {CMS_API_OPTIONS}."
author: ""
date: "$Date$"
revision: "$Revision$"
class
CMS_API_OPTIONS
inherit
WSF_API_OPTIONS
create
make,
make_from_manifest
end

58
library/src/service/cms_request_util.e Normal file
View File

@@ -0,0 +1,58 @@
note
description: "Summary description for {CMS_REQUEST_UTIL}."
author: ""
date: "$Date$"
revision: "$Revision$"
deferred class
CMS_REQUEST_UTIL
inherit
CMS_ENCODERS
REFACTORING_HELPER
feature -- User
current_user_name (req: WSF_REQUEST): detachable READABLE_STRING_32
-- Current user name or Void in case of Guest users.
note
EIS: "src=eiffel:?class=AUTHENTICATION_FILTER&feature=execute"
do
if attached {CMS_USER} current_user (req) as l_user then
Result := l_user.name
end
end
current_user (req: WSF_REQUEST): detachable CMS_USER
-- Current user or Void in case of Guest user.
note
EIS: "eiffel:?class=AUTHENTICATION_FILTER&feature=execute"
do
if attached {CMS_USER} req.execution_variable ("user") as l_user then
Result := l_user
end
end
feature -- Media Type
current_media_type (req: WSF_REQUEST): detachable READABLE_STRING_32
-- Current media type or Void if it's not acceptable.
do
if attached {STRING} req.execution_variable ("media_type") as l_type then
Result := l_type
end
end
feature -- Absolute Host
absolute_host (req: WSF_REQUEST; a_path:STRING): STRING
do
Result := req.absolute_script_url (a_path)
if Result.last_index_of ('/', Result.count) = Result.count then
Result.remove_tail (1)
end
end
end

261
library/src/service/cms_service.e Normal file
View File

@@ -0,0 +1,261 @@
note
description: "[
This class implements the CMS service
It could be used to implement the main EWF service, or
even for a specific handler.
]"
class
CMS_SERVICE
inherit
WSF_ROUTED_SKELETON_SERVICE
rename
execute as execute_service
undefine
requires_proxy
redefine
execute_default
end
WSF_FILTERED_SERVICE
WSF_FILTER
rename
execute as execute_filter
end
WSF_NO_PROXY_POLICY
WSF_URI_HELPER_FOR_ROUTED_SERVICE
WSF_URI_TEMPLATE_HELPER_FOR_ROUTED_SERVICE
REFACTORING_HELPER
SHARED_LOGGER
create
make
feature {NONE} -- Initialization
make (a_api: CMS_API)
-- Build a CMS service with `a_api'
do
api := a_api
configuration := a_api.setup.configuration
initialize
ensure
api_set: api = a_api
end
initialize
-- Initialize various parts of the CMS service.
do
initialize_modules
initialize_users
initialize_auth_engine
initialize_mailer
initialize_router
initialize_filter
end
initialize_modules
-- Intialize modules and keep only enabled modules.
local
l_module: CMS_MODULE
l_available_modules: CMS_MODULE_COLLECTION
do
log.write_debug (generator + ".initialize_modules")
l_available_modules := setup.modules
create modules.make (l_available_modules.count)
across
l_available_modules as ic
loop
l_module := ic.item
if l_module.is_enabled then
modules.extend (l_module)
end
end
ensure
only_enabled_modules: across modules as ic all ic.item.is_enabled end
end
initialize_users
-- Initialize users.
do
end
initialize_mailer
-- Initialize mailer engine.
do
to_implement ("To Implement mailer")
end
initialize_auth_engine
do
to_implement ("To Implement authentication engine")
end
feature -- Settings: router
setup_router
-- <Precursor>
local
l_module: CMS_MODULE
l_api: like api
l_router: like router
do
log.write_debug (generator + ".setup_router")
-- Configure root of api handler.
l_router := router
configure_api_root (l_router)
-- Include routes from modules.
l_api := api
across
modules as ic
loop
l_module := ic.item
l_router.import (l_module.router (l_api))
end
-- Configure files handler.
configure_api_file_handler (l_router)
end
configure_api_root (a_router: WSF_ROUTER)
local
l_root_handler: CMS_ROOT_HANDLER
l_methods: WSF_REQUEST_METHODS
do
log.write_debug (generator + ".configure_api_root")
create l_root_handler.make (api)
create l_methods
l_methods.enable_get
a_router.handle_with_request_methods ("/", l_root_handler, l_methods)
a_router.handle_with_request_methods ("", l_root_handler, l_methods)
end
configure_api_file_handler (a_router: WSF_ROUTER)
local
fhdl: WSF_FILE_SYSTEM_HANDLER
do
log.write_debug (generator + ".configure_api_file_handler")
create fhdl.make_hidden_with_path (setup.layout.www_path)
fhdl.disable_index
fhdl.set_not_found_handler (agent (ia_uri: READABLE_STRING_8; ia_req: WSF_REQUEST; ia_res: WSF_RESPONSE)
do
execute_default (ia_req, ia_res)
end)
a_router.handle_with_request_methods ("/", fhdl, router.methods_GET)
end
feature -- Execute Filter
execute_filter (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Execute the filter.
do
res.put_header_line ("Date: " + (create {HTTP_DATE}.make_now_utc).string)
execute_service (req, res)
end
feature -- Filters
create_filter
-- Create `filter'.
local
f, l_filter: detachable WSF_FILTER
l_module: CMS_MODULE
l_api: like api
do
log.write_debug (generator + ".create_filter")
l_filter := Void
-- Maintenance
create {WSF_MAINTENANCE_FILTER} f
f.set_next (l_filter)
l_filter := f
-- Error Filter
create {CMS_ERROR_FILTER} f.make (api)
f.set_next (l_filter)
l_filter := f
-- Include filters from modules
l_api := api
across
modules as ic
loop
l_module := ic.item
if
l_module.is_enabled and then
attached l_module.filters (l_api) as l_m_filters
then
across l_m_filters as f_ic loop
f := f_ic.item
f.set_next (l_filter)
l_filter := f
end
end
end
filter := l_filter
end
setup_filter
-- Setup `filter'.
local
f: WSF_FILTER
do
log.write_debug (generator + ".setup_filter")
from
f := filter
until
not attached f.next as l_next
loop
f := l_next
end
f.set_next (Current)
end
feature -- Access
api: CMS_API
-- API service.
setup: CMS_SETUP
-- CMS setup.
do
Result := api.setup
end
configuration: CMS_CONFIGURATION
-- CMS configuration.
--| Maybe we can compute it (using `setup') instead of using memory.
modules: CMS_MODULE_COLLECTION
-- Configurator of possible modules.
feature -- Execution
execute_default (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Default request handler if no other are relevant
do
to_implement ("Default response for CMS_SERVICE")
end
note
copyright: "2011-2014, Jocelyn Fiat, Eiffel Software and others"
license: "Eiffel Forum License v2 (see http://www.eiffel.com/licensing/forum.txt)"
source: "[
Eiffel Software
5949 Hollister Ave., Goleta, CA 93117 USA
Telephone 805-685-1006, Fax 805-685-6869
Website http://www.eiffel.com
Customer support http://support.eiffel.com
]"
end

129
library/src/service/cms_url_utilities.e Normal file
View File

@@ -0,0 +1,129 @@
note
description: "Summary description for {CMS_URL_UTILITIES}."
author: ""
date: "$Date$"
revision: "$Revision$"
deferred class
CMS_URL_UTILITIES
inherit
CMS_REQUEST_UTIL
feature -- Core
site_url: READABLE_STRING_8
deferred
end
base_url: detachable READABLE_STRING_8
-- Base url if any.
deferred
end
based_path (p: STRING): STRING
-- Path `p' in the context of the `base_url'
do
if attached base_url as l_base_url then
create Result.make_from_string (l_base_url)
if p.is_empty then
else
if p[1] = '/' then
Result.append (p.substring (2, p.count))
else
Result.append (p)
end
end
else
Result := p
end
end
feature -- Url
absolute_url (a_path: STRING; opts: detachable CMS_API_OPTIONS): STRING
local
l_opts: detachable CMS_API_OPTIONS
do
l_opts := opts
if l_opts = Void then
create l_opts.make (1)
end
l_opts.force (True, "absolute")
Result := url (a_path, l_opts)
end
url (a_path: READABLE_STRING_8; opts: detachable CMS_API_OPTIONS): STRING
-- URL for path `a_path' and optional parameters from `opts'.
--| Options `opts' could be
--| - absolute: True|False => return absolute url
--| - query: string => append "?query"
--| - fragment: string => append "#fragment"
local
q,f: detachable STRING_8
l_abs: BOOLEAN
do
l_abs := False
if opts /= Void then
l_abs := opts.boolean_item ("absolute", l_abs)
if attached opts.item ("query") as l_query then
if attached {READABLE_STRING_8} l_query as s_value then
q := s_value
elseif attached {ITERABLE [TUPLE [key, value: READABLE_STRING_GENERAL]]} l_query as lst then
create q.make_empty
across
lst as c
loop
if q.is_empty then
else
q.append_character ('&')
end
q.append (url_encoded (c.item.key))
q.append_character ('=')
q.append (url_encoded (c.item.value))
end
end
end
if attached opts.string_item ("fragment") as s_frag then
f := s_frag
end
end
if l_abs then
if a_path.substring_index ("://", 1) = 0 then
create Result.make_from_string (site_url)
if a_path.is_empty then
elseif Result.ends_with ("/") then
if a_path[1] = '/' then
Result.append_string (a_path.substring (2, a_path.count))
else
Result.append_string (a_path)
end
else
if a_path[1] = '/' then
Result.append_string (a_path)
else
Result.append_character ('/')
Result.append_string (a_path)
end
end
else
Result := a_path
end
else
Result := based_path (a_path)
end
if q /= Void then
Result.append ("?" + q)
end
if f /= Void then
Result.append ("#" + f)
end
end
checked_url (a_url: READABLE_STRING_8): READABLE_STRING_8
do
Result := a_url
end
end

33
library/src/service/filter/cms_error_filter.e Normal file
View File

@@ -0,0 +1,33 @@
note
description: "Summary description for {CMS_ERROR_FILTER}."
date: "$Date$"
revision: "$Revision$"
class
CMS_ERROR_FILTER
inherit
WSF_URI_TEMPLATE_HANDLER
CMS_HANDLER
WSF_FILTER
create
make
feature -- Basic operations
execute (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Execute the filter
do
if not api.error_handler.has_error then
log.write_information (generator + ".execute")
execute_next (req, res)
else
log.write_critical (generator + ".execute" + api.error_handler.as_string_representation )
(create {ERROR_500_CMS_RESPONSE}.make (req, res, api)).execute
api.error_handler.reset
end
end
end

38
library/src/service/handler/cms_handler.e Normal file
View File

@@ -0,0 +1,38 @@
note
description: "Summary description for {CMS_HANDLER}."
author: ""
date: "$Date$"
revision: "$Revision$"
deferred class
CMS_HANDLER
inherit
WSF_HANDLER
CMS_REQUEST_UTIL
SHARED_LOGGER
REFACTORING_HELPER
feature {NONE} -- Initialization
make (a_api: CMS_API)
do
api := a_api
end
feature -- Setup
setup: CMS_SETUP
do
Result := api.setup
end
feature -- API Service
api: CMS_API
end

54
library/src/service/handler/cms_root_handler.e Normal file
View File

@@ -0,0 +1,54 @@
note
description: "Summary description for {CMS_ROOT_HANDLER}."
date: "$Date$"
revision: "$Revision$"
class
CMS_ROOT_HANDLER
inherit
CMS_HANDLER
WSF_FILTER
WSF_URI_HANDLER
rename
execute as uri_execute,
new_mapping as new_uri_mapping
end
WSF_RESOURCE_HANDLER_HELPER
redefine
do_get
end
REFACTORING_HELPER
create
make
feature -- execute
execute (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Execute request handler
do
execute_methods (req, res)
execute_next (req, res)
end
uri_execute (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Execute request handler
do
execute_methods (req, res)
end
feature -- HTTP Methods
do_get (req: WSF_REQUEST; res: WSF_RESPONSE)
-- <Precursor>
do
(create {HOME_CMS_RESPONSE}.make (req, res, api)).execute
end
end

61
library/src/service/response/cms_generic_response.e Normal file
View File

@@ -0,0 +1,61 @@
note
description: "Summary description for {CMS_GENERIC_RESPONSE}."
date: "$Date$"
revision: "$Revision$"
class
CMS_GENERIC_RESPONSE
feature -- Responses
new_response_redirect (req: WSF_REQUEST; res: WSF_RESPONSE; a_location: READABLE_STRING_32)
-- Redirect to `a_location'
local
h: HTTP_HEADER
do
create h.make
h.put_content_type_text_html
h.put_current_date
h.put_location (a_location)
res.set_status_code ({HTTP_STATUS_CODE}.see_other)
res.put_header_text (h.string)
end
new_response_authenticate (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Handle authenticate.
local
h: HTTP_HEADER
do
create h.make
h.put_content_type_text_html
h.put_current_date
h.put_header_key_value ({HTTP_HEADER_NAMES}.header_www_authenticate, "Basic realm=%"CMSRoc-User%"")
res.set_status_code ({HTTP_STATUS_CODE}.unauthorized)
res.put_header_text (h.string)
end
new_response_denied (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Handle access denied.
local
h: HTTP_HEADER
do
create h.make
h.put_content_type_text_html
h.put_current_date
res.set_status_code ({HTTP_STATUS_CODE}.unauthorized)
res.put_header_text (h.string)
end
new_response_unauthorized (req: WSF_REQUEST; res: WSF_RESPONSE)
-- Handle not authorized.
local
h: HTTP_HEADER
do
create h.make
h.put_content_type_text_html
h.put_current_date
res.set_status_code ({HTTP_STATUS_CODE}.forbidden)
res.put_header_text (h.string)
end
end

983
library/src/service/response/cms_response.e Normal file
View File

@@ -0,0 +1,983 @@
note
description: "Generic CMS Response.It builds the content to get process to render the output"
date: "$Date$"
revision: "$Revision$"
deferred class
CMS_RESPONSE
inherit
CMS_URL_UTILITIES
REFACTORING_HELPER
feature {NONE} -- Initialization
make (req: WSF_REQUEST; res: WSF_RESPONSE; a_api: like api)
do
status_code := {HTTP_STATUS_CODE}.ok
api := a_api
request := req
response := res
create header.make
create values.make (3)
initialize
end
initialize
do
get_theme
create menu_system.make
initialize_block_region_settings
create hook_subscribers.make (0)
register_hooks
end
register_hooks
local
l_module: CMS_MODULE
l_available_modules: CMS_MODULE_COLLECTION
do
l_available_modules := setup.modules
across
l_available_modules as ic
loop
l_module := ic.item
if l_module.is_enabled then
if attached {CMS_HOOK_AUTO_REGISTER} l_module as l_auto then
l_auto.auto_subscribe_to_hooks (Current)
end
l_module.register_hooks (Current)
end
end
end
feature -- Access
request: WSF_REQUEST
response: WSF_RESPONSE
api: CMS_API
-- Current CMS API.
setup: CMS_SETUP
-- Current setup
do
Result := api.setup
end
status_code: INTEGER
header: WSF_HEADER
title: detachable READABLE_STRING_32
page_title: detachable READABLE_STRING_32
-- Page title
main_content: detachable STRING_8
additional_page_head_lines: detachable LIST [READABLE_STRING_8]
-- HTML>head>...extra lines
feature -- URL utilities
is_front: BOOLEAN
-- Is current response related to "front" page?
local
l_path_info: READABLE_STRING_8
do
l_path_info := request.path_info
if attached setup.front_page_path as l_front_page_path then
Result := l_front_page_path.same_string (l_path_info)
else
if attached base_url as l_base_url then
Result := l_path_info.same_string (l_base_url)
else
Result := l_path_info.is_empty or else l_path_info.same_string ("/")
end
end
end
site_url: READABLE_STRING_8
do
Result := absolute_host (request, "")
end
base_url: detachable READABLE_STRING_8
-- Base url if any.
--| Usually it is Void, but it could be
--| /project/demo/
--| FIXME: for now, no way to change that. Always at the root "/"
feature -- Access: CMS
site_name: STRING_32
do
Result := setup.site_name
end
front_page_url: READABLE_STRING_8
do
Result := request.absolute_script_url ("/")
end
values: CMS_VALUE_TABLE
-- Associated values indexed by string name.
feature -- Permission
-- FIXME: to be implemented has_permissions and has_permission.
feature -- Status
-- FIXME: to be implemented
-- is_from, is_module, has_js.
feature -- Head customization
add_additional_head_line (s: READABLE_STRING_8; a_allow_duplication: BOOLEAN)
local
lst: like additional_page_head_lines
do
lst := additional_page_head_lines
if lst = Void then
create {ARRAYED_LIST [like additional_page_head_lines.item]} lst.make (1)
additional_page_head_lines := lst
end
if a_allow_duplication or else across lst as c all not c.item.same_string (s) end then
lst.extend (s)
end
end
add_style (a_href: STRING; a_media: detachable STRING)
local
s: STRING_8
do
s := "<link rel=%"stylesheet%" href=%""+ a_href + "%" type=%"text/css%""
if a_media /= Void then
s.append (" media=%""+ a_media + "%"")
end
s.append ("/>")
add_additional_head_line (s, False)
end
add_javascript_url (a_src: STRING)
local
s: STRING_8
do
s := "<script type=%"text/javascript%" src=%"" + a_src + "%"></script>"
add_additional_head_line (s, False)
end
add_javascript_content (a_script: STRING)
local
s: STRING_8
do
s := "<script type=%"text/javascript%">%N" + a_script + "%N</script>"
add_additional_head_line (s, True)
end
feature -- Element change
set_title (t: like title)
do
title := t
set_page_title (t)
end
set_page_title (t: like page_title)
do
page_title := t
end
set_main_content (s: like main_content)
do
main_content := s
end
set_value (v: detachable ANY; k: READABLE_STRING_GENERAL)
-- Set value `v' associated with name `k'.
do
values.force (v, k)
end
unset_value (k: READABLE_STRING_GENERAL)
-- Unset value associated with name `k'.
do
values.remove (k)
end
feature -- Logging
log (a_category: READABLE_STRING_8; a_message: READABLE_STRING_8; a_level: INTEGER; a_link: detachable CMS_LINK)
local
-- l_log: CMS_LOG
do
debug
to_implement ("Add implemenatation")
end
-- create l_log.make (a_category, a_message, a_level, Void)
-- if a_link /= Void then
-- l_log.set_link (a_link)
-- end
-- l_log.set_info (request.http_user_agent)
-- service.storage.save_log (l_log)
end
feature -- Formats
formats: CMS_FORMATS
once
create Result
end
feature -- Menu
menu_system: CMS_MENU_SYSTEM
main_menu: CMS_MENU
obsolete
"Use `primary_menu' [Nov/2014]"
do
Result := primary_menu
end
primary_menu: CMS_MENU
do
Result := menu_system.primary_menu
end
management_menu: CMS_MENU
do
Result := menu_system.management_menu
end
navigation_menu: CMS_MENU
do
Result := menu_system.navigation_menu
end
user_menu: CMS_MENU
do
Result := menu_system.user_menu
end
primary_tabs: CMS_MENU
do
Result := menu_system.primary_tabs
end
feature -- Blocks initialization
initialize_block_region_settings
local
l_table: like block_region_settings
do
debug ("refactor_fixme")
fixme ("CHECK:Can we use the same structure as in theme.info?")
fixme ("let the user choose ...")
end
create regions.make_caseless (5)
create l_table.make_caseless (10)
l_table["top"] := "top"
l_table["header"] := "header"
l_table["highlighted"] := "highlighted"
l_table["help"] := "help"
l_table["content"] := "content"
l_table["footer"] := "footer"
l_table["management"] := "first_sidebar"
l_table["navigation"] := "first_sidebar"
l_table["user"] := "first_sidebar"
l_table["bottom"] := "page_bottom"
block_region_settings := l_table
end
feature -- Blocks regions
regions: STRING_TABLE [CMS_BLOCK_REGION]
-- Layout regions, that contains blocks.
block_region_settings: STRING_TABLE [STRING]
block_region (b: CMS_BLOCK; a_default_region: detachable READABLE_STRING_8): CMS_BLOCK_REGION
-- Region associated with block `b', or else `a_default_region' if provided.
local
l_region_name: detachable READABLE_STRING_8
do
l_region_name := block_region_settings.item (b.name)
if l_region_name = Void then
if a_default_region /= Void then
l_region_name := a_default_region
else
-- Default .. put it in same named region
-- Maybe a bad idea
l_region_name := b.name.as_lower
end
end
if attached regions.item (l_region_name) as res then
Result := res
else
create Result.make (l_region_name)
regions.force (Result, l_region_name)
end
end
feature -- Blocks
add_block (b: CMS_BLOCK; a_default_region: detachable READABLE_STRING_8)
-- Add block `b' to associated region or `a_default_region' if provided.
local
l_region: detachable like block_region
do
l_region := block_region (b, a_default_region)
l_region.extend (b)
end
get_blocks
do
debug ("refactor_fixme")
fixme ("find a way to have this in configuration or database, and allow different order")
end
add_block (top_header_block, "top")
add_block (header_block, "header")
if attached message_block as m then
add_block (m, "content")
end
-- FIXME: avoid hardcoded html! should be only in theme.
add_block (create {CMS_CONTENT_BLOCK}.make_raw ("top_content_anchor", Void, "<a id=%"main-content%"></a>%N", formats.full_html), "content")
if attached page_title as l_page_title then
-- FIXME: avoid hardcoded html! should be only in theme.
add_block (create {CMS_CONTENT_BLOCK}.make_raw ("page_title", Void, "<h1 id=%"page-title%" class=%"title%">"+ l_page_title +"</h1>%N", formats.full_html), "content")
end
if attached primary_tabs_block as m then
add_block (m, "content")
end
add_block (content_block, "content")
if attached management_menu_block as l_block then
add_block (l_block, "first_sidebar")
end
if attached navigation_menu_block as l_block then
add_block (l_block, "first_sidebar")
end
if attached user_menu_block as l_block then
add_block (l_block, "first_sidebar")
end
if attached footer_block as l_block then
add_block (l_block, "footer")
end
invoke_block
end
primary_menu_block: detachable CMS_MENU_BLOCK
do
if attached primary_menu as m and then not m.is_empty then
create Result.make (m)
end
end
management_menu_block: detachable CMS_MENU_BLOCK
do
if attached management_menu as m and then not m.is_empty then
create Result.make (m)
end
end
navigation_menu_block: detachable CMS_MENU_BLOCK
do
if attached navigation_menu as m and then not m.is_empty then
create Result.make (m)
end
end
user_menu_block: detachable CMS_MENU_BLOCK
do
if attached user_menu as m and then not m.is_empty then
create Result.make (m)
end
end
primary_tabs_block: detachable CMS_MENU_BLOCK
do
if attached primary_tabs as m and then not m.is_empty then
create Result.make (m)
end
end
top_header_block: CMS_CONTENT_BLOCK
local
s: STRING
do
create s.make_empty
create Result.make ("page_top", Void, s, formats.full_html)
Result.set_is_raw (True)
end
header_block: CMS_CONTENT_BLOCK
local
s: STRING
l_hb: STRING
do
create s.make_from_string (theme.menu_html (primary_menu, True))
create l_hb.make_empty
create Result.make ("header", Void, l_hb, formats.full_html)
Result.set_is_raw (True)
end
horizontal_primary_menu_html: STRING
do
create Result.make_empty
Result.append ("<div id=%"menu-bar%">")
Result.append (theme.menu_html (primary_menu, True))
Result.append ("</div>")
end
message_html: detachable STRING
do
if attached message as m and then not m.is_empty then
Result := "<div id=%"message%">" + m + "</div>"
end
end
message_block: detachable CMS_CONTENT_BLOCK
do
if attached message as m and then not m.is_empty then
create Result.make ("message", Void, "<div id=%"message%">" + m + "</div>", formats.full_html)
Result.set_is_raw (True)
end
end
content_block: CMS_CONTENT_BLOCK
local
s: STRING
do
if attached main_content as l_content then
s := l_content
else
s := ""
debug
s := "No Content"
end
end
create Result.make ("content", Void, s, formats.full_html)
Result.set_is_raw (True)
end
made_with_html: STRING
do
create Result.make_empty
Result.append ("Made with <a href=%"http://www.eiffel.com/%">EWF</a>")
end
footer_block: CMS_CONTENT_BLOCK
do
create Result.make ("made_with", Void, made_with_html, Void)
end
feature -- Hooks
hook_subscribers: HASH_TABLE [LIST [CMS_HOOK], TYPE [CMS_HOOK]]
-- Hook indexed by hook identifier.
subscribe_to_hook (h: CMS_HOOK; a_hook_type: TYPE [CMS_HOOK])
-- Subscribe `h' to hooks identified by `a_hook_type'.
local
lst: detachable LIST [CMS_HOOK]
do
lst := hook_subscribers.item (a_hook_type)
if lst = Void then
create {ARRAYED_LIST [CMS_HOOK]} lst.make (1)
hook_subscribers.force (lst, a_hook_type)
end
if not lst.has (h) then
lst.force (h)
end
end
feature -- Hook: value alter
subscribe_to_value_table_alter_hook (h: CMS_HOOK_VALUE_TABLE_ALTER)
-- Add `h' as subscriber of value table alter hooks CMS_HOOK_VALUE_TABLE_ALTER.
do
subscribe_to_hook (h, {CMS_HOOK_VALUE_TABLE_ALTER})
end
invoke_value_table_alter (a_table: CMS_VALUE_TABLE)
-- Invoke value table alter hook for table `a_table'.
do
if attached hook_subscribers.item ({CMS_HOOK_VALUE_TABLE_ALTER}) as lst then
across
lst as c
loop
if attached {CMS_HOOK_VALUE_TABLE_ALTER} c.item as h then
h.value_table_alter (a_table, Current)
end
end
end
end
feature -- Hook: menu_system_alter
subscribe_to_menu_system_alter_hook (h: CMS_HOOK_MENU_SYSTEM_ALTER)
-- Add `h' as subscriber of menu system alter hooks CMS_HOOK_MENU_SYSTEM_ALTER.
do
subscribe_to_hook (h, {CMS_HOOK_MENU_SYSTEM_ALTER})
end
invoke_menu_system_alter (a_menu_system: CMS_MENU_SYSTEM)
-- Invoke menu system alter hook for menu `a_menu_system'.
do
if attached hook_subscribers.item ({CMS_HOOK_MENU_SYSTEM_ALTER}) as lst then
across
lst as c
loop
if attached {CMS_HOOK_MENU_SYSTEM_ALTER} c.item as h then
h.menu_system_alter (a_menu_system, Current)
end
end
end
end
feature -- Hook: menu_alter
subscribe_to_menu_alter_hook (h: CMS_HOOK_MENU_ALTER)
-- Add `h' as subscriber of menu alter hooks CMS_HOOK_MENU_ALTER.
do
subscribe_to_hook (h, {CMS_HOOK_MENU_ALTER})
end
invoke_menu_alter (a_menu: CMS_MENU)
-- Invoke menu alter hook for menu `a_menu'.
do
if attached hook_subscribers.item ({CMS_HOOK_MENU_ALTER}) as lst then
across
lst as c
loop
if attached {CMS_HOOK_MENU_ALTER} c.item as h then
h.menu_alter (a_menu, Current)
end
end
end
end
feature -- Hook: form_alter
subscribe_to_form_alter_hook (h: CMS_HOOK_FORM_ALTER)
-- Add `h' as subscriber of form alter hooks CMS_HOOK_FORM_ALTER.
do
subscribe_to_hook (h, {CMS_HOOK_MENU_ALTER})
end
invoke_form_alter (a_form: CMS_FORM; a_form_data: detachable WSF_FORM_DATA)
-- Invoke form alter hook for form `a_form' and associated data `a_form_data'
do
if attached hook_subscribers.item ({CMS_HOOK_FORM_ALTER}) as lst then
across
lst as c
loop
if attached {CMS_HOOK_FORM_ALTER} c.item as h then
h.form_alter (a_form, a_form_data, Current)
end
end
end
end
feature -- Hook: block
subscribe_to_block_hook (h: CMS_HOOK_BLOCK)
-- Add `h' as subscriber of hooks CMS_HOOK_BLOCK.
do
subscribe_to_hook (h, {CMS_HOOK_BLOCK})
end
invoke_block
-- Invoke block hook in order to get block from modules.
do
if attached hook_subscribers.item ({CMS_HOOK_BLOCK}) as lst then
across
lst as c
loop
if attached {CMS_HOOK_BLOCK} c.item as h then
across
h.block_list as blst
loop
h.get_block_view (blst.item, Current)
end
end
end
end
end
feature -- Menu: change
add_to_main_menu (lnk: CMS_LINK)
obsolete
"use add_to_primary_menu [Nov/2014]"
do
add_to_primary_menu (lnk)
end
add_to_primary_menu (lnk: CMS_LINK)
do
add_to_menu (lnk, primary_menu)
end
add_to_menu (lnk: CMS_LINK; m: CMS_MENU)
do
-- if attached {CMS_LOCAL_LINK} lnk as l_local then
-- l_local.get_is_active (request)
-- end
m.extend (lnk)
end
feature -- Message
add_message (a_msg: READABLE_STRING_8; a_category: detachable READABLE_STRING_8)
local
m: like message
do
m := message
if m = Void then
create m.make (a_msg.count + 9)
message := m
end
if a_category /= Void then
m.append ("<li class=%""+ a_category +"%">")
else
m.append ("<li>")
end
m.append (a_msg + "</li>")
end
add_notice_message (a_msg: READABLE_STRING_8)
do
add_message (a_msg, "notice")
end
add_warning_message (a_msg: READABLE_STRING_8)
do
add_message (a_msg, "warning")
end
add_error_message (a_msg: READABLE_STRING_8)
do
add_message (a_msg, "error")
end
add_success_message (a_msg: READABLE_STRING_8)
do
add_message (a_msg, "success")
end
report_form_errors (fd: WSF_FORM_DATA)
require
has_error: not fd.is_valid
do
if attached fd.errors as errs then
across
errs as err
loop
if attached err.item as e then
if attached e.field as l_field then
if attached e.message as e_msg then
add_error_message (e_msg) --"Field [" + l_field.name + "] is invalid. " + e_msg)
else
add_error_message ("Field [" + l_field.name + "] is invalid.")
end
elseif attached e.message as e_msg then
add_error_message (e_msg)
end
end
end
end
end
message: detachable STRING_8
feature -- Theme
theme: CMS_THEME
-- Current theme
get_theme
local
l_info: CMS_THEME_INFORMATION
do
if attached setup.theme_information_location as fn then
create l_info.make (fn)
else
create l_info.make_default
end
if l_info.engine.is_case_insensitive_equal_general ("smarty") then
create {SMARTY_CMS_THEME} theme.make (setup, l_info)
else
create {DEFAULT_CMS_THEME} theme.make (setup, l_info)
end
end
feature -- Element Change
set_status_code (a_status: INTEGER)
-- Set `status_code' with `a_status'.
note
EIS: "src=eiffel:?class=HTTP_STATUS_CODE"
do
to_implement ("Feature to test if a_status is a valid status code!!!.")
status_code := a_status
ensure
status_code_set: status_code = a_status
end
feature -- Generation
prepare (page: CMS_HTML_PAGE)
do
-- Menu
add_to_primary_menu (create {CMS_LOCAL_LINK}.make ("Home", "/"))
invoke_menu_system_alter (menu_system)
prepare_menu_system (menu_system)
-- Blocks
get_blocks
across
regions as reg_ic
loop
across
reg_ic.item.blocks as ic
loop
if attached {CMS_MENU_BLOCK} ic.item as l_menu_block then
recursive_get_active (l_menu_block.menu, request)
end
end
end
-- Values
common_prepare (page)
custom_prepare (page)
-- Cms values
invoke_value_table_alter (values)
-- Predefined values
page.register_variable (page, "page") -- DO NOT REMOVE
-- Values Associated with current Execution object.
across
values as ic
loop
page.register_variable (ic.item, ic.key)
end
-- Block rendering
across
regions as reg_ic
loop
across
reg_ic.item.blocks as ic
loop
page.add_to_region (theme.block_html (ic.item), reg_ic.item.name)
end
end
-- Additional lines in <head ../>
if attached additional_page_head_lines as l_head_lines then
across
l_head_lines as hl
loop
page.head_lines.force (hl.item)
end
end
end
common_prepare (page: CMS_HTML_PAGE)
-- Common preparation for page `page'.
do
debug ("refactor_fixme")
fixme ("Fix generation common")
end
-- Information
page.set_title (title)
debug ("cms")
if title = Void then
page.set_title ("CMS::" + request.path_info) --| FIXME: probably, should be removed and handled by theme.
end
end
-- Variables
page.register_variable (request.absolute_script_url (""), "site_url")
page.register_variable (request.absolute_script_url (""), "host") -- Same as `site_url'.
if attached current_user_name (request) as l_user then
page.register_variable (l_user, "user")
end
page.register_variable (title, "site_title")
page.set_is_front (is_front)
-- Variables/Setup
page.register_variable (setup.is_web, "web")
page.register_variable (setup.is_html, "html")
-- Variables/Misc
-- FIXME: logo .. could be a settings of theme, managed by admin front-end/database.
-- if attached logo_location as l_logo then
-- page.register_variable (l_logo, "logo")
-- end
-- Menu...
page.register_variable (horizontal_primary_menu_html, "primary_nav")
end
custom_prepare (page: CMS_HTML_PAGE)
-- Common preparation for page `page' that can be redefined by descendants.
do
end
prepare_menu_system (a_menu_system: CMS_MENU_SYSTEM)
do
across
a_menu_system as c
loop
prepare_links (c.item)
end
end
prepare_links (a_menu: CMS_LINK_COMPOSITE)
local
to_remove: ARRAYED_LIST [CMS_LINK]
do
create to_remove.make (0)
across
a_menu as c
loop
if attached {CMS_LOCAL_LINK} c.item as lm then
-- if attached lm.permission_arguments as perms and then not has_permissions (perms) then
-- to_remove.force (lm)
-- else
-- if lm.permission_arguments is Void , this is permitted
get_local_link_active_status (lm)
if attached {CMS_LINK_COMPOSITE} lm as comp then
prepare_links (comp)
end
-- end
elseif attached {CMS_LINK_COMPOSITE} c.item as comp then
prepare_links (comp)
end
end
across
to_remove as c
loop
a_menu.remove (c.item)
end
end
recursive_get_active (a_comp: CMS_LINK_COMPOSITE; req: WSF_REQUEST)
-- Update the active status recursively on `a_comp'.
local
ln: CMS_LINK
do
if attached a_comp.items as l_items then
across
l_items as ic
loop
ln := ic.item
if attached {CMS_LOCAL_LINK} ln as l_local then
get_local_link_active_status (l_local)
end
if (ln.is_expanded or ln.is_collapsed) and then attached {CMS_LINK_COMPOSITE} ln as l_comp then
recursive_get_active (l_comp, req)
end
end
end
end
get_local_link_active_status (a_lnk: CMS_LOCAL_LINK)
-- Get `a_lnk.is_active' value according to `request' data.
local
qs: STRING
l_is_active: BOOLEAN
do
create qs.make_from_string (request.percent_encoded_path_info)
l_is_active := qs.same_string (a_lnk.location)
if not l_is_active then
if attached request.query_string as l_query_string and then not l_query_string.is_empty then
qs.append_character ('?')
qs.append (l_query_string)
end
l_is_active := qs.same_string (a_lnk.location)
end
a_lnk.set_is_active (l_is_active)
end
feature -- Custom Variables
variables: detachable STRING_TABLE[ANY]
-- Custom variables to feed the templates.
feature -- Element change: Add custom variables.
add_variable (a_element: ANY; a_key:READABLE_STRING_32)
local
l_variables: like variables
do
l_variables := variables
if l_variables = Void then
create l_variables.make (5)
variables := l_variables
end
l_variables.force (a_element, a_key)
end
feature -- Execution
execute
do
begin
process
terminate
end
feature {NONE} -- Execution
begin
do
end
process
deferred
end
frozen terminate
local
cms_page: CMS_HTML_PAGE
page: CMS_HTML_PAGE_RESPONSE
do
create cms_page.make
prepare (cms_page)
create page.make (theme.page_html (cms_page))
page.set_status_code (status_code)
page.header.put_content_length (page.html.count)
page.header.put_current_date
response.send (page)
on_terminated
end
on_terminated
do
end
end

37
library/src/service/response/error_500_cms_response.e Normal file
View File

@@ -0,0 +1,37 @@
note
description: "Summary description for {ERROR_500_CMS_RESPONSE}."
date: "$Date$"
revision: "$Revision$"
class
ERROR_500_CMS_RESPONSE
inherit
CMS_RESPONSE
redefine
custom_prepare
end
create
make
feature -- Generation
custom_prepare (page: CMS_HTML_PAGE)
do
page.register_variable (request.absolute_script_url (request.path_info), "request")
page.set_status_code ({HTTP_STATUS_CODE}.internal_server_error)
page.register_variable (page.status_code.out, "code")
end
feature -- Execution
process
-- Computed response message.
do
set_title ("Internal Server Error")
set_page_title (Void)
end
end

37
library/src/service/response/generic_view_cms_response.e Normal file
View File

@@ -0,0 +1,37 @@
note
description: "Summary description for {NODE_VIEW_CMS_RESPONSE}."
date: "$Date$"
revision: "$Revision$"
class
GENERIC_VIEW_CMS_RESPONSE
inherit
CMS_RESPONSE
redefine
custom_prepare
end
create
make
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 -- Execution
process
-- Computed response message.
do
-- set_title ("CMS")
-- set_page_title (Void)
end
end

36
library/src/service/response/home_cms_response.e Normal file
View File

@@ -0,0 +1,36 @@
note
description: "Summary description for {HOME_CMS_RESPONSE}."
date: "$Date$"
revision: "$Revision$"
class
HOME_CMS_RESPONSE
inherit
CMS_RESPONSE
redefine
custom_prepare
end
create
make
feature -- Generation
custom_prepare (page: CMS_HTML_PAGE)
do
Precursor (page)
page.register_variable (api.recent_nodes (0, 5), "nodes")
end
feature -- Execution
process
-- Computed response message.
do
set_title (Void)
set_page_title (Void)
end
end

37
library/src/service/response/not_implemented_error_cms_response.e Normal file
View File

@@ -0,0 +1,37 @@
note
description: "Summary description for {NOT_IMPLEMENTED_ERROR_CMS_RESPONSE}."
date: "$Date$"
revision: "$Revision$"
class
NOT_IMPLEMENTED_ERROR_CMS_RESPONSE
inherit
CMS_RESPONSE
redefine
custom_prepare
end
create
make
feature -- Generation
custom_prepare (page: CMS_HTML_PAGE)
do
page.register_variable (request.absolute_script_url (request.path_info), "request")
page.register_variable ("501", "code")
page.set_status_code (501)
end
feature -- Execution
process
-- Computed response message.
do
set_title ("Not Implemented")
set_page_title (Void)
end
end