%%%----------------------------------------------------------------------
%%% File    : ejabberd_web_admin.erl
%%% Author  : Alexey Shchepin <alexey@process-one.net>
%%% Purpose : Administration web interface
%%% Created :  9 Apr 2004 by Alexey Shchepin <alexey@process-one.net>
%%%
%%%
%%% ejabberd, Copyright (C) 2002-2011   ProcessOne
%%%
%%% This program is free software; you can redistribute it and/or
%%% modify it under the terms of the GNU General Public License as
%%% published by the Free Software Foundation; either version 2 of the
%%% License, or (at your option) any later version.
%%%
%%% This program is distributed in the hope that it will be useful,
%%% but WITHOUT ANY WARRANTY; without even the implied warranty of
%%% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
%%% General Public License for more details.
%%%
%%% You should have received a copy of the GNU General Public License
%%% along with this program; if not, write to the Free Software
%%% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
%%% 02111-1307 USA
%%%
%%%----------------------------------------------------------------------

%%%% definitions

-module(ejabberd_web_admin).
-author('alexey@process-one.net').

%% External exports
-export([process/2,
	 list_users/4,
	 list_users_in_diapason/4,
	 pretty_print_xml/1,
	 term_to_id/1]).

-include("ejabberd.hrl").
-include("jlib.hrl").
-include("ejabberd_http.hrl").
-include("ejabberd_web_admin.hrl").

-define(INPUTATTRS(Type, Name, Value, Attrs),
	?XA("input", Attrs ++
	    [{"type", Type},
	     {"name", Name},
	     {"value", Value}])).

%%%==================================
%%%% get_acl_access

%% @spec (Path::[string()], Method) -> {HostOfRule, [AccessRule]}
%% where Method = 'GET' | 'POST'

%% All accounts can access those URLs
get_acl_rule([],_) -> {"localhost", [all]};
get_acl_rule(["style.css"],_) -> {"localhost", [all]};
get_acl_rule(["logo.png"],_) -> {"localhost", [all]};
get_acl_rule(["logo-fill.png"],_) -> {"localhost", [all]};
get_acl_rule(["favicon.ico"],_) -> {"localhost", [all]};
get_acl_rule(["additions.js"],_) -> {"localhost", [all]};
%% This page only displays vhosts that the user is admin:
get_acl_rule(["vhosts"],_) -> {"localhost", [all]};

%% The pages of a vhost are only accesible if the user is admin of that vhost:
get_acl_rule(["server", VHost | _RPath], Method)
    when Method=:='GET' orelse Method=:='HEAD' ->
    {VHost, [configure, webadmin_view]};
get_acl_rule(["server", VHost | _RPath], 'POST') -> {VHost, [configure]};

%% Default rule: only global admins can access any other random page
get_acl_rule(_RPath, Method)
    when Method=:='GET' orelse Method=:='HEAD' ->
    {global, [configure, webadmin_view]};
get_acl_rule(_RPath, 'POST') -> {global, [configure]}.

is_acl_match(Host, Rules, Jid) ->
    lists:any(
      fun(Rule) ->
	      allow == acl:match_rule(Host, Rule, Jid)
      end,
      Rules).

%%%==================================
%%%% Menu Items Access

get_jid(Auth, HostHTTP, Method) ->
    case get_auth_admin(Auth, HostHTTP, [], Method) of
        {ok, {User, Server}} ->
	    jlib:make_jid(User, Server, "");
	{unauthorized, Error} ->
	    ?ERROR_MSG("Unauthorized ~p: ~p", [Auth, Error]),
	    throw({unauthorized, Auth})
    end.

get_menu_items(global, cluster, Lang, JID) ->
    {Base, _, Items} = make_server_menu([], [], Lang, JID),
    lists:map(
	fun({URI, Name}) ->
		{Base++URI++"/", Name};
	   ({URI, Name, _SubMenu}) ->
		{Base++URI++"/", Name}
	end,
	Items
    );
get_menu_items(Host, cluster, Lang, JID) ->
    {Base, _, Items} = make_host_menu(Host, [], Lang, JID),
    lists:map(
	fun({URI, Name}) ->
		{Base++URI++"/", Name};
	   ({URI, Name, _SubMenu}) ->
		{Base++URI++"/", Name}
	end,
	Items
    ).
%% get_menu_items(Host, Node, Lang, JID) ->
%%     {Base, _, Items} = make_host_node_menu(Host, Node, Lang, JID),
%%     lists:map(
%% 	fun({URI, Name}) ->
%% 		{Base++URI++"/", Name};
%% 	   ({URI, Name, _SubMenu}) ->
%% 		{Base++URI++"/", Name}
%% 	end,
%% 	Items
%%     ).

is_allowed_path(BasePath, {Path, _}, JID) ->
    is_allowed_path(BasePath ++ [Path], JID);
is_allowed_path(BasePath, {Path, _, _}, JID) ->
    is_allowed_path(BasePath ++ [Path], JID).

is_allowed_path(["admin" | Path], JID) ->
    is_allowed_path(Path, JID);
is_allowed_path(Path, JID) ->
    {HostOfRule, AccessRule} = get_acl_rule(Path, 'GET'),
    is_acl_match(HostOfRule, AccessRule, JID).

%% @spec(Path) -> URL
%% where Path = [string()]
%%       URL = string()
%% Convert ["admin", "user", "tom"] -> "/admin/user/tom/"
%%path_to_url(Path) ->
%%    "/" ++ string:join(Path, "/") ++ "/".

%% @spec(URL) -> Path
%% where Path = [string()]
%%       URL = string()
%% Convert "admin/user/tom" -> ["admin", "user", "tom"]
url_to_path(URL) ->
    string:tokens(URL, "/").
  
%%%==================================
%%%% process/2

process(["doc", LocalFile], _Request) ->
    DocPath = case os:getenv("EJABBERD_DOC_PATH") of
		  P when is_list(P) -> P;
		  false -> "/share/doc/ejabberd/"
	      end,
    %% Code based in mod_http_fileserver
    FileName = filename:join(DocPath, LocalFile),
    case file:read_file(FileName) of
        {ok, FileContents} ->
            ?DEBUG("Delivering content.", []),
            {200,
             [{"Server", "ejabberd"}],
             FileContents};
        {error, Error} ->
            ?DEBUG("Delivering error: ~p", [Error]),
	    Help = " " ++ FileName ++ " - Try to specify the path to ejabberd documentation "
		"with the environment variable EJABBERD_DOC_PATH. Check the ejabberd Guide for more information.",
            case Error of
                eacces -> {403, [], "Forbidden"++Help};
                enoent -> {404, [], "Not found"++Help};
                _Else -> {404, [], atom_to_list(Error)++Help}
            end
    end;

process(["server", SHost | RPath] = Path, #request{auth = Auth, lang = Lang, host = HostHTTP, method = Method} = Request) ->
    Host = jlib:nameprep(SHost),
    case lists:member(Host, ?MYHOSTS) of
	true ->
	    case get_auth_admin(Auth, HostHTTP, Path, Method) of
		{ok, {User, Server}} ->
		    AJID = get_jid(Auth, HostHTTP, Method),
		    process_admin(Host, Request#request{path = RPath,
							auth = {auth_jid, Auth, AJID},
							us = {User, Server}});
		{unauthorized, "no-auth-provided"} ->
		    {401,
		     [{"WWW-Authenticate", "basic realm=\"ejabberd\""}],
		     ejabberd_web:make_xhtml([?XCT("h1", "Unauthorized")])};
		{unauthorized, Error} ->
		    {BadUser, _BadPass} = Auth,
		    {IPT, _Port} = Request#request.ip,
		    IPS = inet_parse:ntoa(IPT),
		    ?WARNING_MSG("Access of ~p from ~p failed with error: ~p",
				 [BadUser, IPS, Error]),
		    {401,
		     [{"WWW-Authenticate",
		       "basic realm=\"auth error, retry login to ejabberd\""}],
		     ejabberd_web:make_xhtml([?XCT("h1", "Unauthorized")])}
	    end;
	false ->
            ejabberd_web:error(not_found)
    end;

process(RPath, #request{auth = Auth, lang = Lang, host = HostHTTP, method = Method} = Request) ->
    case get_auth_admin(Auth, HostHTTP, RPath, Method) of
	{ok, {User, Server}} ->
	    AJID = get_jid(Auth, HostHTTP, Method),
	    process_admin(global, Request#request{path = RPath,
						  auth = {auth_jid, Auth, AJID},
						  us = {User, Server}});
        {unauthorized, "no-auth-provided"} ->
	    {401,
	     [{"WWW-Authenticate", "basic realm=\"ejabberd\""}],
	     ejabberd_web:make_xhtml([?XCT("h1", "Unauthorized")])};
	{unauthorized, Error} ->
	    {BadUser, _BadPass} = Auth,
	    {IPT, _Port} = Request#request.ip,
	    IPS = inet_parse:ntoa(IPT),
	    ?WARNING_MSG("Access of ~p from ~p failed with error: ~p",
			 [BadUser, IPS, Error]),
	    {401,
	     [{"WWW-Authenticate",
	       "basic realm=\"auth error, retry login to ejabberd\""}],
	     ejabberd_web:make_xhtml([?XCT("h1", "Unauthorized")])}
    end.

get_auth_admin(Auth, HostHTTP, RPath, Method) ->
    case Auth of
        {SJID, Pass} ->
	    {HostOfRule, AccessRule} = get_acl_rule(RPath, Method),
            case jlib:string_to_jid(SJID) of
                error ->
                    {unauthorized, "badformed-jid"};
                #jid{user = "", server = User} ->
		    %% If the user only specified username, not username@server
		    get_auth_account(HostOfRule, AccessRule, User, HostHTTP, Pass);
                #jid{user = User, server = Server} ->
		    get_auth_account(HostOfRule, AccessRule, User, Server, Pass)
            end;
	undefined ->
            {unauthorized, "no-auth-provided"}
    end.

get_auth_account(HostOfRule, AccessRule, User, Server, Pass) ->
    case ejabberd_auth:check_password(User, Server, Pass) of
	true ->
	    case is_acl_match(HostOfRule, AccessRule,
				jlib:make_jid(User, Server, "")) of
		false ->
		    {unauthorized, "unprivileged-account"};
		true ->
		    {ok, {User, Server}}
	    end;
	false ->
	    case ejabberd_auth:is_user_exists(User, Server) of
		true ->
		    {unauthorized, "bad-password"};
		false ->
		    {unauthorized, "inexistent-account"}
	    end
    end.

%%%==================================
%%%% make_xhtml

make_xhtml(Els, Host, Lang, JID) ->
    make_xhtml(Els, Host, cluster, Lang, JID).

%% @spec (Els, Host, Node, Lang, JID) -> {200, [html], xmlelement()}
%% where Host = global | string()
%%       Node = cluster | atom()
%%       JID = jid()
make_xhtml(Els, Host, Node, Lang, JID) ->
    Base = get_base_path(Host, cluster), %% Enforcing 'cluster' on purpose here
    MenuItems = make_navigation(Host, Node, Lang, JID),
    {200, [html],
     {xmlelement, "html", [{"xmlns", "http://www.w3.org/1999/xhtml"},
			   {"xml:lang", Lang},
			   {"lang", Lang}],
      [{xmlelement, "head", [],
	[?XCT("title", "ejabberd Web Admin"),
	 {xmlelement, "meta", [{"http-equiv", "Content-Type"},
			       {"content", "text/html; charset=utf-8"}], []},
	 {xmlelement, "script", [{"src", Base ++ "/additions.js"},
				 {"type", "text/javascript"}], [?C(" ")]},
	 {xmlelement, "link", [{"href", Base ++ "favicon.ico"},
			       {"type", "image/x-icon"},
			       {"rel", "shortcut icon"}], []},
	 {xmlelement, "link", [{"href", Base ++ "style.css"},
			       {"type", "text/css"},
			       {"rel", "stylesheet"}], []}]},
       ?XE("body",
           [?XAE("div",
		 [{"id", "container"}],
		 [?XAE("div",
		       [{"id", "header"}],
		       [?XE("h1",
			    [?ACT("/admin/", "ejabberd Web Admin")]
			   )]),
		  ?XAE("div",
		       [{"id", "navigation"}],
		       [?XE("ul",
			    MenuItems
			   )]),
		  ?XAE("div",
		       [{"id", "content"}],
		       Els),
		  ?XAE("div",
		       [{"id", "clearcopyright"}],
		       [{xmlcdata, ""}])]),
	    ?XAE("div",
		 [{"id", "copyrightouter"}],
		 [?XAE("div",
		       [{"id", "copyright"}],
		       [?XC("p",
			     "ejabberd (c) 2002-2011 ProcessOne")
		       ])])])
      ]}}.

get_base_path(global, cluster) -> "/admin/";
get_base_path(Host, cluster) -> "/admin/server/" ++ Host ++ "/";
get_base_path(global, Node) -> "/admin/node/" ++ atom_to_list(Node) ++ "/";
get_base_path(Host, Node) -> "/admin/server/" ++ Host ++ "/node/" ++ atom_to_list(Node) ++ "/".

%%%==================================
%%%% css & images

additions_js() ->
"
function selectAll() {
  for(i=0;i<document.forms[0].elements.length;i++)
  { var e = document.forms[0].elements[i];
    if(e.type == 'checkbox')
    { e.checked = true; }
  }
}
function unSelectAll() {
  for(i=0;i<document.forms[0].elements.length;i++)
  { var e = document.forms[0].elements[i];
    if(e.type == 'checkbox')
    { e.checked = false; }
  }
}
".

css(Host) ->
    Base = get_base_path(Host, cluster),
    "
html,body {
  background: white;
  margin: 0;
  padding: 0;
  height: 100%;
}

#container {
  padding: 0;
  margin: 0;
  min-height: 100%;
  height: 100%;
  margin-bottom: -30px;
}

html>body #container {
  height: auto;
}

#header h1 {
  width: 100%;
  height: 55px;
  padding: 0;
  margin: 0;
  background: transparent url(\"" ++ Base ++ "logo-fill.png\");
}

#header h1 a {
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 55px;
  padding: 0;
  margin: 0;
  background: transparent url(\"" ++ Base ++ "logo.png\") no-repeat;
  display: block;
  text-indent: -700em;
}

#clearcopyright {
  display: block;
  width: 100%;
  height: 30px;
}

#copyrightouter {
  display: table;
  width: 100%;
  height: 30px;
}

#copyright {
  display: table-cell;
  vertical-align: bottom;
  width: 100%;
  height: 30px;
}

#copyright p {
  margin-left: 0;
  margin-right: 0;
  margin-top: 5px;
  margin-bottom: 0;
  padding-left: 0;
  padding-right: 0;
  padding-top: 1px;
  padding-bottom: 1px;
  width: 100%;
  color: #ffffff;
  background-color: #fe8a00;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 7pt;
  font-weight: bold;
  text-align: center;
}

#navigation ul {
  position: absolute;
  top: 65px;
  left: 0;
  padding: 0 1px 1px 1px;
  margin: 0;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 8pt;
  font-weight: bold;
  border-top: 1px solid #d47911;
  width: 17em;
}

#navigation ul li {
  list-style: none;
  margin: 0;
  text-align: left;
  display: inline;
}

#navigation ul li a {
  margin: 0;
  display: block;
  padding: 3px 6px 3px 9px;
  border-left: 1em solid #ffc78c;
  border-right: 1px solid #d47911;
  border-bottom: 1px solid #d47911;
  background: #ffe3c9;
  text-decoration: none;
}

#navigation ul li a:link {
  color: #844;
}

#navigation ul li a:visited {
 color: #766;
}

#navigation ul li a:hover {
  border-color: #fc8800;
  color: #FFF;
  background: #332;
}

ul li #navhead a, ul li #navheadsub a, ul li #navheadsubsub a {
  text-align: center;
  border-top: 1px solid #d47911;
  border-bottom: 2px solid #d47911;
  background: #FED6A6;
}

#navheadsub, #navitemsub {
  border-left: 7px solid white;
  margin-left: 2px;
}

#navheadsubsub, #navitemsubsub {
  border-left: 14px solid white;
  margin-left: 4px;
}

#lastactivity li {
  font-weight: bold;
  border: 1px solid #d6760e;
  background-color: #fff2e8;
  padding: 2px;
  margin-bottom: -1px;
}

td.copy {
  color: #ffffff;
  background-color: #fe8a00;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 7pt;
  font-weight: bold;
  text-align: center;
}

input {
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  border: 1px solid #d6760e;
  color: #723202;
  background-color: #fff2e8;
  vertical-align: middle;
  margin-bottom: 0px;
  padding: 0.1em;
}

input[type=submit] {
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 8pt;
  font-weight: bold;
  color: #ffffff;
  background-color: #fe8a00;
  border: 1px solid #d6760e;
}

textarea {
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  border: 1px solid #d6760e;
  color: #723202;
  background-color: #fff2e8;
}

select {
  border: 1px solid #d6760e;
  color: #723202;
  background-color: #fff2e8;
  vertical-align: middle;
  margin-bottom: 0px; 
  padding: 0.1em;
}

thead {
  color: #000000;
  background-color: #ffffff;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  font-weight: bold;
}

tr.head {
  color: #ffffff;
  background-color: #3b547a;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 9pt;
  font-weight: bold;
  text-align: center;
}

tr.oddraw {
  color: #412c75;
  background-color: #ccd4df;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 9pt;
  font-weight: normal;
  text-align: center;
}

tr.evenraw {
  color: #412c75;
  background-color: #dbe0e8;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 9pt;
  font-weight: normal;
  text-align: center;
}

td.leftheader {
  color: #412c75;
  background-color: #ccccc1;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 9pt;
  font-weight: bold;
  padding-left: 5px;
  padding-top: 2px;
  padding-bottom: 2px;
  margin-top: 0px;
  margin-bottom: 0px;
}

td.leftcontent {
  color: #000044;
  background-color: #e6e6df;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 7pt;
  font-weight: normal;
  padding-left: 5px;
  padding-right: 5px;
  padding-top: 2px;
  padding-bottom: 2px;
  margin-top: 0px;
  margin-bottom: 0px;
}

td.rightcontent {
  color: #000044;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  font-weight: normal;
  text-align: justify;
  padding-left: 10px;
  padding-right: 10px;
  padding-bottom: 5px;
}


h1 {
  color: #000044;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 14pt;
  font-weight: bold;
  text-align: center;
  padding-top: 2px;
  padding-bottom: 2px;
  margin-top: 0px;
  margin-bottom: 0px;
}

h2 {
  color: #000044;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 12pt;
  font-weight: bold;
  text-align: center;
  padding-top: 2px;
  padding-bottom: 2px;
  margin-top: 0px;
  margin-bottom: 0px;
}

h3 {
  color: #000044;
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  font-weight: bold;
  text-align: left;
  padding-top: 20px;
  padding-bottom: 2px;
  margin-top: 0px;
  margin-bottom: 0px;
}

#content a:link {
  color: #990000; 
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  font-weight: bold;
  text-decoration: underline;
}
#content a:visited {
  color: #990000;  
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  font-weight: bold;
  text-decoration: underline;
}
#content a:hover {
  color: #cc6600;  
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  font-weight: bold;
  text-decoration: underline;
}


#content ul li {
  list-style-type: disc;
  font-size: 10pt;
  /*font-size: 7pt;*/
  padding-left: 10px;
}

#content ul.nolistyle>li {
  list-style-type: none;
}

#content li.big {
  font-size: 10pt;
}

#content {
  font-family: Verdana, Arial, Helvetica, sans-serif; 
  font-size: 10pt;
  padding-left: 17em;
  padding-top: 5px;
}

div.guidelink {
  text-align: right;
  padding-right: 1em;
}

table.withtextareas>tbody>tr>td {
  vertical-align: top;
}

p.result {
  border: 1px;
  border-style: dashed;
  border-color: #FE8A02;
  padding: 1em;
  margin-right: 1em;
  background: #FFE3C9;
}

*.alignright {
  font-size: 10pt;
  text-align: right;
}

".

favicon() ->
    jlib:decode_base64(
      "AAABAAEAEBAQAAEABAAoAQAAFgAAACgAAAAQAAAAIAAAAAEABAAAAAAAAAA"
      "AAAAAAAAAAAAAAAAAAAAAAAAJf+cAAIPsAAGC8gAVhecAAIr8ACiR7wBBmO"
      "cAUKPsAFun8ABhqeoAgLryAJLB8ACz1PcAv9r7AMvi+gAAAAAAAgICARMhI"
      "CAkJCQkQkFCQgICN2d2cSMgJCRevdvVQkICAlqYh5MgICQkXrRCQkJCMgI7"
      "kiAjICAUFF2swkFBQRQUXazCQUFBAgI7kiAgICAkJF60QkJCQgICOpiHkyA"
      "gJCRevdvlQkICAjdndnMgICQkJCRCQkJCAgICARAgICAAAAAAAAAAAAAAAA"
      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
      "AAAAAAAAAAA").

logo() ->
    jlib:decode_base64(
      "iVBORw0KGgoAAAANSUhEUgAAAVcAAAA3CAMAAACPbPnEAAAAAXNSR0IArs4c"
      "6QAAAEtQTFRFcTIA1XcE/YsA/40E/pIH/JYc/5kg/54i/KIu/6U6/apE/61H"
      "/61P/bFX/7Vh/bda/rpq/L5s/8J2/cJ8/8qI/86Y/9aj/9mt/+bJ7EGiPwAA"
      "AZRJREFUeNrt28lug0AQhGHajrPv+/s/aVwpDlgE0gQ3tqO/DhxihMg33VJ7"
      "JmmCVKSJlVJ4bZQ93Jl/zjJv+8tzcMUVV1xxLXIlRfPAZptYrbf5YeW618PW"
      "yvG8w/g9ZwquuJ6Y6+bbdY0rrifhSmrmgUulVXbVDq3H39Zy6Cf9+8c7JNM/"
      "mXeY8+SMRmuIK6644oprkSupmQdulLhQdup1qJKmrmWmVpb5NN9LUyddu7nn"
      "LYkrrrjiimuVK6mZB+6VuFbiXJk8v/bnv0PVa+Yd5tdr/x7vCfqbgPsfV1xx"
      "xRXXKldSMw+8KPGgxJWyU7WZE538p0vOr/lOm/q7dPf+bOVKvVXiUcEVV1xx"
      "xbXMldTMA29KPCtxp7T6XpvxE6/9nm/l987mnG9l5u/8jO4Ot9uTEq8Krrji"
      "iiuuZa6kZh74UFpli3sO61btMfyHyWGv/RMs7wB67ne32/BdwRVXXHHFtcyV"
      "1MwDn0qrbHHvyPT/Dsarla/R/1GpQydYPhf0bqC/A7jz7YkrrrjiimuVK6nI"
      "F5dWoNvcLcs/AAAAAElFTkSuQmCC").

logo_fill() ->
    jlib:decode_base64(
      "iVBORw0KGgoAAAANSUhEUgAAAAYAAAA3BAMAAADdxCZzAAAAAXNSR0IArs4c"
      "6QAAAB5QTFRF1nYO/ooC/o4O/pIS/p4q/q5K/rpq/sqM/tam/ubGzn/S/AAA"
      "AEFJREFUCNdlw0sRwCAQBUE+gSRHLGABC1jAAhbWAhZwC+88XdXOXb4UlFAr"
      "SmwN5ekdJY2BkudEec1QvrVQ/r3xOlK9HsTvertmAAAAAElFTkSuQmCC").

%%%==================================
%%%% process_admin

process_admin(global,
	      #request{path = [],
		       auth = {_, _, AJID},
		       lang = Lang}) ->
    %%Base = get_base_path(global, cluster),
    make_xhtml(?H1GL(?T("Administration"), "toc", "Contents") ++
		[?XE("ul",
		    [?LI([?ACT(MIU, MIN)]) || {MIU, MIN} <- get_menu_items(global, cluster, Lang, AJID)]
		   )
	       ], global, Lang, AJID);

process_admin(Host,
	      #request{path = [],
		       auth = {_, _Auth, AJID},
		       lang = Lang}) ->
    %%Base = get_base_path(Host, cluster),
    make_xhtml([?XCT("h1", "Administration"),
		?XE("ul",
		    [?LI([?ACT(MIU, MIN)]) || {MIU, MIN} <- get_menu_items(Host, cluster, Lang, AJID)]
		   )
	       ], Host, Lang, AJID);

process_admin(Host, #request{path = ["style.css"]}) ->
    {200, [{"Content-Type", "text/css"}, last_modified(), cache_control_public()], css(Host)};

process_admin(_Host, #request{path = ["favicon.ico"]}) ->
    {200, [{"Content-Type", "image/x-icon"}, last_modified(), cache_control_public()], favicon()};

process_admin(_Host, #request{path = ["logo.png"]}) ->
    {200, [{"Content-Type", "image/png"}, last_modified(), cache_control_public()], logo()};

process_admin(_Host, #request{path = ["logo-fill.png"]}) ->
    {200, [{"Content-Type", "image/png"}, last_modified(), cache_control_public()], logo_fill()};

process_admin(_Host, #request{path = ["additions.js"]}) ->
    {200, [{"Content-Type", "text/javascript"}, last_modified(), cache_control_public()], additions_js()};

process_admin(Host,
	      #request{path = ["acls-raw"],
		       q = Query,
		       auth = {_, _Auth, AJID},
		       lang = Lang}) ->

    Res = case lists:keysearch("acls", 1, Query) of
	      {value, {_, String}} ->
		  case erl_scan:string(String) of
		      {ok, Tokens, _} ->
			  case erl_parse:parse_term(Tokens) of
			      {ok, NewACLs} ->
				  case acl:add_list(Host, NewACLs, true) of
				      ok ->
					  ok;
				      _ ->
					  error
				  end;
			      _ ->
				  error
			  end;
		      _ ->
			  error
		  end;
	      _ ->
		  nothing
	  end,
    ACLs = lists:keysort(2, ets:select(acl, [{{acl, {'$1', Host}, '$2'},
					      [], [{{acl, '$1', '$2'}}]}])),
    {NumLines, ACLsP} = term_to_paragraph(ACLs, 80),
    make_xhtml(?H1GL(?T("Access Control Lists"), "ACLDefinition", "ACL Definition") ++
	       case Res of
		   ok -> [?XREST("Submitted")];
		   error -> [?XREST("Bad format")];
		   nothing -> []
	       end ++
	       [?XAE("form", [{"action", ""}, {"method", "post"}],
		     [?TEXTAREA("acls", integer_to_list(lists:max([16, NumLines])), "80", ACLsP++"."),
		      ?BR,
		      ?INPUTT("submit", "submit", "Submit")
		     ])
	       ], Host, Lang, AJID);

process_admin(Host,
	      #request{method = Method,
			path = ["acls"],
		        auth = {_, _Auth, AJID},
			q = Query,
			lang = Lang}) ->
    ?DEBUG("query: ~p", [Query]),
    Res = case Method of
	      'POST' ->
		  case catch acl_parse_query(Host, Query) of
		      {'EXIT', _} ->
			  error;
		      NewACLs ->
			  ?INFO_MSG("NewACLs at ~s: ~p", [Host, NewACLs]),
			  case acl:add_list(Host, NewACLs, true) of
			      ok ->
				  ?INFO_MSG("NewACLs: ok", []),
				  ok;
			      _ ->
				  error
			  end
		  end;
	      _ ->
		  nothing
	  end,
    ACLs = lists:keysort(
	     2, ets:select(acl, [{{acl, {'$1', Host}, '$2'},
				  [], [{{acl, '$1', '$2'}}]}])),
    make_xhtml(?H1GL(?T("Access Control Lists"), "ACLDefinition", "ACL Definition") ++
	       case Res of
		   ok -> [?XREST("Submitted")];
		   error -> [?XREST("Bad format")];
		   nothing -> []
	       end ++
	       [?XE("p", [?ACT("../acls-raw/", "Raw")])] ++
	       [?XAE("form", [{"action", ""}, {"method", "post"}],
		     [acls_to_xhtml(ACLs),
		      ?BR,
		      ?INPUTT("submit", "delete", "Delete Selected"),
		      ?C(" "),
		      ?INPUTT("submit", "submit", "Submit")
		     ])
	       ], Host, Lang, AJID);

process_admin(Host,
	      #request{path = ["access-raw"],
		       auth = {_, _Auth, AJID},
			q = Query,
			lang = Lang}) ->
    SetAccess =
	fun(Rs) ->
		mnesia:transaction(
		  fun() ->
			  Os = mnesia:select(
				 config,
				 [{{config, {access, '$1', Host}, '$2'},
				   [],
				   ['$_']}]),
			  lists:foreach(fun(O) ->
						mnesia:delete_object(O)
					end, Os),
			  lists:foreach(
			    fun({access, Name, Rules}) ->
				    mnesia:write({config,
						  {access, Name, Host},
						  Rules})
			    end, Rs)
		  end)
	end,
    Res = case lists:keysearch("access", 1, Query) of
	      {value, {_, String}} ->
		  case erl_scan:string(String) of
		      {ok, Tokens, _} ->
			  case erl_parse:parse_term(Tokens) of
			      {ok, Rs} ->
				  case SetAccess(Rs) of
				      {atomic, _} ->
					  ok;
				      _ ->
					  error
				  end;
			      _ ->
				  error
			  end;
		      _ ->
			  error
		  end;
	      _ ->
		  nothing
	  end,
    Access =
	    ets:select(config,
			       [{{config, {access, '$1', Host}, '$2'},
				 [],
				 [{{access, '$1', '$2'}}]}]),
    {NumLines, AccessP} = term_to_paragraph(Access, 80),
    make_xhtml(?H1GL(?T("Access Rules"), "AccessRights", "Access Rights") ++
	       case Res of
		   ok -> [?XREST("Submitted")];
		   error -> [?XREST("Bad format")];
		   nothing -> []
	       end ++
	       [?XAE("form", [{"action", ""}, {"method", "post"}],
		     [?TEXTAREA("access", integer_to_list(lists:max([16, NumLines])), "80", AccessP++"."),
		      ?BR,
		      ?INPUTT("submit", "submit", "Submit")
		     ])
	       ], Host, Lang, AJID);

process_admin(Host,
	      #request{method = Method,
		       path = ["access"],
		       q = Query,
		       auth = {_, _Auth, AJID},
		       lang = Lang}) ->
    ?DEBUG("query: ~p", [Query]),
    Res = case Method of
	      'POST' ->
		  case catch access_parse_query(Host, Query) of
		      {'EXIT', _} ->
			  error;
		      ok ->
			  ok
		  end;
	      _ ->
		  nothing
	  end,
    AccessRules =
	ets:select(config,
		   [{{config, {access, '$1', Host}, '$2'},
		     [],
		     [{{access, '$1', '$2'}}]}]),
    make_xhtml(?H1GL(?T("Access Rules"), "AccessRights", "Access Rights") ++
	       case Res of
		   ok -> [?XREST("Submitted")];
		   error -> [?XREST("Bad format")];
		   nothing -> []
	       end ++
	       [?XE("p", [?ACT("../access-raw/", "Raw")])] ++
	       [?XAE("form", [{"action", ""}, {"method", "post"}],
		     [access_rules_to_xhtml(AccessRules, Lang),
		      ?BR,
		      ?INPUTT("submit", "delete", "Delete Selected")
		     ])
	       ], Host, Lang, AJID);

process_admin(Host,
	      #request{path = ["access", SName],
		       q = Query,
		       auth = {_, _Auth, AJID},
		       lang = Lang}) ->
    ?DEBUG("query: ~p", [Query]),
    Name = list_to_atom(SName),
    Res = case lists:keysearch("rules", 1, Query) of
	      {value, {_, String}} ->
		  case parse_access_rule(String) of
		      {ok, Rs} ->
			  ejabberd_config:add_global_option(
			    {access, Name, Host}, Rs),
			  ok;
		      _ ->
			  error
		  end;
	      _ ->
		  nothing
	  end,
    Rules = case ejabberd_config:get_global_option({access, Name, Host}) of
		undefined ->
		    [];
		Rs1 ->
		    Rs1
	    end,
    make_xhtml([?XC("h1",
		    io_lib:format(?T("~s access rule configuration"), [SName]))] ++
	       case Res of
		   ok -> [?XREST("Submitted")];
		   error -> [?XREST("Bad format")];
		   nothing -> []
	       end ++
	       [?XAE("form", [{"action", ""}, {"method", "post"}],
		     [access_rule_to_xhtml(Rules),
		      ?BR,
		      ?INPUTT("submit", "submit", "Submit")
		     ])
	       ], Host, Lang, AJID);

process_admin(global,
	      #request{path = ["vhosts"],
		       auth = {_, _Auth, AJID},
		       lang = Lang}) ->
    Res = list_vhosts(Lang, AJID),
    make_xhtml(?H1GL(?T("Virtual Hosts"), "virtualhost", "Virtual Hosting") ++ Res, global, Lang, AJID);

process_admin(Host,
	      #request{path = ["users"],
		       q = Query,
		       auth = {_, _Auth, AJID},
		       lang = Lang}) when is_list(Host) ->
    Res = list_users(Host, Query, Lang, fun url_func/1),
    make_xhtml([?XCT("h1", "Users")] ++ Res, Host, Lang, AJID);

process_admin(Host,
	      #request{path = ["users", Diap],
		       auth = {_, _Auth, AJID},
		       lang = Lang}) when is_list(Host) ->
    Res = list_users_in_diapason(Host, Diap, Lang, fun url_func/1),
    make_xhtml([?XCT("h1", "Users")] ++ Res, Host, Lang, AJID);

process_admin(Host,
	      #request{
		       path = ["online-users"],
		       auth = {_, _Auth, AJID},
		       lang = Lang}) when is_list(Host) ->
    Res = list_online_users(Host, Lang),
    make_xhtml([?XCT("h1", "Online Users")] ++ Res, Host, Lang, AJID);

process_admin(Host,
	      #request{path = ["last-activity"],
		       auth = {_, _Auth, AJID},
		       q = Query,
		       lang = Lang}) when is_list(Host) ->
    ?DEBUG("query: ~p", [Query]),
    Month = case lists:keysearch("period", 1, Query) of
		{value, {_, Val}} ->
		    Val;
		_ ->
		    "month"
	    end,
    Res = case lists:keysearch("ordinary", 1, Query) of
	      {value, {_, _}} ->
		  list_last_activity(Host, Lang, false, Month);
	      _ ->
		  list_last_activity(Host, Lang, true, Month)
	  end,
    make_xhtml([?XCT("h1", "Users Last Activity")] ++
	       [?XAE("form", [{"action", ""}, {"method", "post"}],
		     [?CT("Period: "),
		      ?XAE("select", [{"name", "period"}],
			   lists:map(
			     fun({O, V}) ->
				    Sel = if
					      O == Month -> [{"selected", "selected"}];
					      true -> []
					  end,
				    ?XAC("option",
					 Sel ++ [{"value", O}], V)
			     end, [{"month", ?T("Last month")},
				   {"year", ?T("Last year")},
				   {"all", ?T("All activity")}])),
		      ?C(" "),
		      ?INPUTT("submit", "ordinary", "Show Ordinary Table"),
		      ?C(" "),
		      ?INPUTT("submit", "integral", "Show Integral Table")
		     ])] ++
	       Res, Host, Lang, AJID);

process_admin(Host,
	      #request{path = ["stats"],
		       auth = {_, _Auth, AJID},
		       lang = Lang}) ->
    Res = get_stats(Host, Lang),
    make_xhtml([?XCT("h1", "Statistics")] ++ Res, Host, Lang, AJID);

process_admin(Host,
	      #request{path = ["user", U],
		       auth = {_, _Auth, AJID},
		       q = Query,
		       lang = Lang}) ->
    case ejabberd_auth:is_user_exists(U, Host) of
	true ->
	    Res = user_info(U, Host, Query, Lang),
	    make_xhtml(Res, Host, Lang, AJID);
	false ->
	    make_xhtml([?XCT("h1", "Not Found")], Host, Lang, AJID)
    end;

process_admin(Host,
	      #request{path = ["nodes"],
		       auth = {_, _Auth, AJID},
		       lang = Lang}) ->
    Res = get_nodes(Lang),
    make_xhtml(Res, Host, Lang, AJID);

process_admin(Host,
	      #request{path = ["node", SNode | NPath],
		       auth = {_, _Auth, AJID},
		       q = Query,
		       lang = Lang}) ->
    case search_running_node(SNode) of
	false ->
	    make_xhtml([?XCT("h1", "Node not found")], Host, Lang, AJID);
	Node ->
	    Res = get_node(Host, Node, NPath, Query, Lang),
	    make_xhtml(Res, Host, Node, Lang, AJID)
    end;

%%%==================================
%%%% process_admin default case

process_admin(Host, #request{lang = Lang, 
		       auth = {_, _Auth, AJID}
		    } = Request) ->
    {Hook, Opts} = case Host of
		       global -> {webadmin_page_main, [Request]};
		       Host -> {webadmin_page_host, [Host, Request]}
		   end,
    case ejabberd_hooks:run_fold(Hook, Host, [], Opts) of
	[] -> setelement(1, make_xhtml([?XC("h1", "Not Found")], Host, Lang, AJID), 404);
	Res -> make_xhtml(Res, Host, Lang, AJID)
    end.

%%%==================================
%%%% acl

acls_to_xhtml(ACLs) ->
    ?XAE("table", [],
	 [?XE("tbody",
	      lists:map(
		fun({acl, Name, Spec} = ACL) ->
			SName = atom_to_list(Name),
			ID = term_to_id(ACL),
			?XE("tr",
			    [?XE("td", [?INPUT("checkbox", "selected", ID)]),
			     ?XC("td", SName)] ++
			    acl_spec_to_xhtml(ID, Spec)
			   )
		end, ACLs) ++
	      [?XE("tr",
		   [?X("td"),
		    ?XE("td", [?INPUT("text", "namenew", "")])
		   ] ++
		   acl_spec_to_xhtml("new", {user, ""})
		  )]
	     )]).

acl_spec_to_text({user, U}) ->
    {user, U};

acl_spec_to_text({server, S}) ->
    {server, S};

acl_spec_to_text({user, U, S}) ->
    {user, U ++ "@" ++ S};

acl_spec_to_text({user_regexp, RU}) ->
    {user_regexp, RU};

acl_spec_to_text({user_regexp, RU, S}) ->
    {user_regexp, RU ++ "@" ++ S};

acl_spec_to_text({server_regexp, RS}) ->
    {server_regexp, RS};

acl_spec_to_text({node_regexp, RU, RS}) ->
    {node_regexp, RU ++ "@" ++ RS};

acl_spec_to_text({user_glob, RU}) ->
    {user_glob, RU};

acl_spec_to_text({user_glob, RU, S}) ->
    {user_glob, RU ++ "@" ++ S};

acl_spec_to_text({server_glob, RS}) ->
    {server_glob, RS};

acl_spec_to_text({node_glob, RU, RS}) ->
    {node_glob, RU ++ "@" ++ RS};

acl_spec_to_text(all) ->
    {all, ""};

acl_spec_to_text(Spec) ->
    {raw, term_to_string(Spec)}.

acl_spec_to_xhtml(ID, Spec) ->
    {Type, Str} = acl_spec_to_text(Spec),
    [acl_spec_select(ID, Type), ?ACLINPUT(Str)].

acl_spec_select(ID, Opt) ->
    ?XE("td",
	[?XAE("select", [{"name", "type" ++ ID}],
	      lists:map(
		fun(O) ->
			Sel = if
				  O == Opt -> [{"selected", "selected"}];
				  true -> []
			      end,
			?XAC("option",
			     Sel ++ [{"value", atom_to_list(O)}],
			     atom_to_list(O))
		end, [user, server, user_regexp, server_regexp, 
		      node_regexp, user_glob, server_glob, node_glob, all, raw]))]).


%% @spec (T::any()) -> StringLine::string()
term_to_string(T) ->
    StringParagraph = lists:flatten(io_lib:format("~1000000p", [T])),
    %% Remove from the string all the carriage returns characters
    {ok, StringLine, _} = regexp:gsub(StringParagraph, "\\n ", ""),
    StringLine.

%% @spec (T::any(), Cols::integer()) -> {NumLines::integer(), Paragraph::string()}
term_to_paragraph(T, Cols) ->
    Paragraph = erl_prettypr:format(erl_syntax:abstract(T), [{paper, Cols}]),
    {ok, FieldList} = regexp:split(Paragraph, "\n"),
    NumLines = length(FieldList),
    {NumLines, Paragraph}.

term_to_id(T) ->
    jlib:encode_base64(binary_to_list(term_to_binary(T))).


acl_parse_query(Host, Query) ->
    ACLs = ets:select(acl, [{{acl, {'$1', Host}, '$2'},
			     [], [{{acl, '$1', '$2'}}]}]),
    case lists:keysearch("submit", 1, Query) of
	{value, _} ->
	    acl_parse_submit(ACLs, Query);
	_ ->
	    case lists:keysearch("delete", 1, Query) of
		{value, _} ->
		    acl_parse_delete(ACLs, Query)
	    end
    end.

acl_parse_submit(ACLs, Query) ->
    NewACLs =
	lists:map(
	  fun({acl, Name, Spec} = ACL) ->
		  %%SName = atom_to_list(Name),
		  ID = term_to_id(ACL),
		  case {lists:keysearch("type" ++ ID, 1, Query),
			lists:keysearch("value" ++ ID, 1, Query)} of
		      {{value, {_, T}}, {value, {_, V}}} ->
			  {Type, Str} = acl_spec_to_text(Spec),
			  case {atom_to_list(Type), Str} of
			      {T, V} ->
				  ACL;
			      _ ->
				  NewSpec = string_to_spec(T, V),
				  {acl, Name, NewSpec}
			  end;
		      _ ->
			  ACL
		  end
	  end, ACLs),
    NewACL = case {lists:keysearch("namenew", 1, Query),
		   lists:keysearch("typenew", 1, Query),
		   lists:keysearch("valuenew", 1, Query)} of
		 {{value, {_, ""}}, _, _} ->
		     [];
		 {{value, {_, N}}, {value, {_, T}}, {value, {_, V}}} ->
		     NewName = list_to_atom(N),
		     NewSpec = string_to_spec(T, V),
		     [{acl, NewName, NewSpec}];
		 _ ->
		     []
	     end,
    NewACLs ++ NewACL.

string_to_spec("user", Val) ->
    string_to_spec2(user, Val);
string_to_spec("server", Val) ->
    {server, Val};
string_to_spec("user_regexp", Val) ->
    string_to_spec2(user_regexp, Val);
string_to_spec("server_regexp", Val) ->
    {server_regexp, Val};
string_to_spec("node_regexp", Val) ->
    #jid{luser = U, lserver = S, resource = ""} = jlib:string_to_jid(Val),
    {node_regexp, U, S};
string_to_spec("user_glob", Val) ->
    string_to_spec2(user_glob, Val);
string_to_spec("server_glob", Val) ->
    {server_glob, Val};
string_to_spec("node_glob", Val) ->
    #jid{luser = U, lserver = S, resource = ""} = jlib:string_to_jid(Val),
    {node_glob, U, S};
string_to_spec("all", _) ->
    all;
string_to_spec("raw", Val) ->
    {ok, Tokens, _} = erl_scan:string(Val ++ "."),
    {ok, NewSpec} = erl_parse:parse_term(Tokens),
    NewSpec.

string_to_spec2(ACLName, Val) ->
    #jid{luser = U, lserver = S, resource = ""} = jlib:string_to_jid(Val),
    case U of
	"" -> 
	    {ACLName, S};
	_ -> 
	    {ACLName, U, S}
    end.


acl_parse_delete(ACLs, Query) ->
    NewACLs =
	lists:filter(
	  fun({acl, _Name, _Spec} = ACL) ->
		  ID = term_to_id(ACL),
		  not lists:member({"selected", ID}, Query)
	  end, ACLs),
    NewACLs.


access_rules_to_xhtml(AccessRules, Lang) ->
    ?XAE("table", [],
	 [?XE("tbody",
	      lists:map(
		fun({access, Name, Rules} = Access) ->
			SName = atom_to_list(Name),
			ID = term_to_id(Access),
			?XE("tr",
			    [?XE("td", [?INPUT("checkbox", "selected", ID)]),
			     ?XE("td", [?AC(SName ++ "/", SName)]),
			     ?XC("td", term_to_string(Rules))
			    ]
			   )
		end, AccessRules) ++
	      [?XE("tr",
		   [?X("td"),
		    ?XE("td", [?INPUT("text", "namenew", "")]),
		    ?XE("td", [?INPUTT("submit", "addnew", "Add New")])
		   ]
		  )]
	     )]).

access_parse_query(Host, Query) ->
    AccessRules =
	ets:select(config,
		   [{{config, {access, '$1', Host}, '$2'},
		     [],
		     [{{access, '$1', '$2'}}]}]),
    case lists:keysearch("addnew", 1, Query) of
	{value, _} ->
	    access_parse_addnew(AccessRules, Host, Query);
	_ ->
	    case lists:keysearch("delete", 1, Query) of
		{value, _} ->
		    access_parse_delete(AccessRules, Host, Query)
	    end
    end.

access_parse_addnew(_AccessRules, Host, Query) ->
    case lists:keysearch("namenew", 1, Query) of
	{value, {_, String}} when String /= "" ->
	    Name = list_to_atom(String),
	    ejabberd_config:add_global_option({access, Name, Host}, []),
	    ok
    end.

access_parse_delete(AccessRules, Host, Query) ->
    lists:foreach(
      fun({access, Name, _Rules} = AccessRule) ->
	      ID = term_to_id(AccessRule),
	      case lists:member({"selected", ID}, Query) of
		  true ->
		      mnesia:transaction(
			fun() ->
				mnesia:delete({config, {access, Name, Host}})
			end);
		  _ ->
		      ok
	      end
      end, AccessRules),
    ok.




access_rule_to_xhtml(Rules) ->
    Text = lists:flatmap(
	     fun({Access, ACL} = _Rule) ->
		     SAccess = element_to_list(Access),
		     SACL = atom_to_list(ACL),
		     SAccess ++ "\s\t" ++ SACL ++ "\n"
	     end, Rules),
    ?XAC("textarea", [{"name", "rules"},
		      {"rows", "16"},
		      {"cols", "80"}],
	 Text).

parse_access_rule(Text) ->
    Strings = string:tokens(Text, "\r\n"),
    case catch lists:flatmap(
		 fun(String) ->
			 case string:tokens(String, "\s\t") of
			     [Access, ACL] ->
				 [{list_to_element(Access), list_to_atom(ACL)}];
			     [] ->
				 []
			 end
		 end, Strings) of
	{'EXIT', _Reason} ->
	    error;
	Rs ->
	    {ok, Rs}
    end.

%%%==================================
%%%% list_vhosts

list_vhosts(Lang, JID) ->
    Hosts = ?MYHOSTS,
    HostsAllowed = lists:filter(
		     fun(Host) ->
			     is_acl_match(Host, [configure, webadmin_view], JID)
		     end,
		     Hosts
		    ),
    list_vhosts2(Lang, HostsAllowed).

list_vhosts2(Lang, Hosts) ->
    SHosts = lists:sort(Hosts),
    [?XE("table",
	 [?XE("thead",
	      [?XE("tr",
		   [?XCT("td", "Host"),
		    ?XCT("td", "Registered Users"),
		    ?XCT("td", "Online Users")
		   ])]),
	  ?XE("tbody",
	      lists:map(
		fun(Host) ->
			OnlineUsers =
			    length(ejabberd_sm:get_vh_session_list(Host)),
			RegisteredUsers =
			    ejabberd_auth:get_vh_registered_users_number(Host),
			?XE("tr",
			    [?XE("td", [?AC("../server/" ++ Host ++ "/", Host)]),
			     ?XC("td", pretty_string_int(RegisteredUsers)),
			     ?XC("td", pretty_string_int(OnlineUsers))
			    ])
		end, SHosts)
	     )])].

%%%==================================
%%%% list_users

list_users(Host, Query, Lang, URLFunc) ->
    Res = list_users_parse_query(Query, Host),
    Users = ejabberd_auth:get_vh_registered_users(Host),
    SUsers = lists:sort([{S, U} || {U, S} <- Users]),
    FUsers =
	case length(SUsers) of
	    N when N =< 100 ->
		[list_given_users(Host, SUsers, "../", Lang, URLFunc)];
	    N ->
		NParts = trunc(math:sqrt(N * 0.618)) + 1,
		M = trunc(N / NParts) + 1,
		lists:flatmap(
		  fun(K) ->
			  L = K + M - 1,
			  %%Node = integer_to_list(K) ++ "-" ++ integer_to_list(L),
			  Last = if L < N -> su_to_list(lists:nth(L, SUsers));
				    true -> su_to_list(lists:last(SUsers))
				 end,
			  Name = 
			      su_to_list(lists:nth(K, SUsers)) ++
			      [$\s, 226, 128, 148, $\s] ++
			      Last,
			  [?AC(URLFunc({user_diapason, K, L}), Name), ?BR]
		  end, lists:seq(1, N, M))
	end,
    case Res of
	ok -> [?XREST("Submitted")];
	error -> [?XREST("Bad format")];
	nothing -> []
    end ++
	[?XAE("form", [{"action", ""}, {"method", "post"}],
	      [?XE("table",
		   [?XE("tr",
			[?XC("td", ?T("User") ++ ":"),
			 ?XE("td", [?INPUT("text", "newusername", "")]),
			 ?XE("td", [?C([" @ ", Host])])
			]),
		    ?XE("tr",
			[?XC("td", ?T("Password") ++ ":"),
			 ?XE("td", [?INPUT("password", "newuserpassword", "")]),
			 ?X("td")
			]),
		    ?XE("tr",
			[?X("td"),
			 ?XAE("td", [{"class", "alignright"}],
			      [?INPUTT("submit", "addnewuser", "Add User")]),
			 ?X("td")
			])]),
	       ?P] ++
	      FUsers)].

%% Parse user creation query and try register:
list_users_parse_query(Query, Host) ->
    case lists:keysearch("addnewuser", 1, Query) of
	{value, _} ->
	    {value, {_, Username}} =
		lists:keysearch("newusername", 1, Query),
	    {value, {_, Password}} =
		lists:keysearch("newuserpassword", 1, Query),
	    case jlib:string_to_jid(Username++"@"++Host) of
		error ->
		    error;
		#jid{user = User, server = Server} ->
		    case ejabberd_auth:try_register(User, Server, Password) of
			{error, _Reason} ->
			    error;
			_ ->
			    ok
		    end
	    end;
	false ->
	    nothing
    end.


list_users_in_diapason(Host, Diap, Lang, URLFunc) ->
    Users = ejabberd_auth:get_vh_registered_users(Host),
    SUsers = lists:sort([{S, U} || {U, S} <- Users]),
    {ok, [S1, S2]} = regexp:split(Diap, "-"),
    N1 = list_to_integer(S1),
    N2 = list_to_integer(S2),
    Sub = lists:sublist(SUsers, N1, N2 - N1 + 1),
    [list_given_users(Host, Sub, "../../", Lang, URLFunc)].

list_given_users(Host, Users, Prefix, Lang, URLFunc) ->
    ModLast = get_lastactivity_module(Host),
    ModOffline = get_offlinemsg_module(Host),
    ?XE("table",
	[?XE("thead",
	     [?XE("tr",
		  [?XCT("td", "User"),
		   ?XCT("td", "Offline Messages"),
		   ?XCT("td", "Last Activity")])]),
	 ?XE("tbody",
	     lists:map(
	       fun(_SU = {Server, User}) ->
		       US = {User, Server},
		       QueueLenStr = get_offlinemsg_length(ModOffline, User, Server),
		       FQueueLen = [?AC(URLFunc({users_queue, Prefix,
						 User, Server}),
					QueueLenStr)],
		       FLast =
			   case ejabberd_sm:get_user_resources(User, Server) of
			       [] ->
				   case ModLast:get_last_info(User, Server) of
				       not_found ->
					   ?T("Never");
				       {ok, Shift, _Status} ->
					   TimeStamp = {Shift div 1000000,
							Shift rem 1000000,
							0},
					   {{Year, Month, Day}, {Hour, Minute, Second}} =
					       calendar:now_to_local_time(TimeStamp),
					   lists:flatten(
					     io_lib:format(
					       "~w-~.2.0w-~.2.0w ~.2.0w:~.2.0w:~.2.0w",
					       [Year, Month, Day, Hour, Minute, Second]))
				   end;
			       _ ->
				   ?T("Online")
			   end,
		       ?XE("tr",
			   [?XE("td",
				[?AC(URLFunc({user, Prefix,
					      ejabberd_http:url_encode(User),
					      Server}),
				     us_to_list(US))]),
			    ?XE("td", FQueueLen),
			    ?XC("td", FLast)])
	       end, Users)
	    )]).

get_offlinemsg_length(ModOffline, User, Server) ->
    case ModOffline of
	none -> "disabled";
	_ -> pretty_string_int(ModOffline:get_queue_length(User, Server))
    end.

get_offlinemsg_module(Server) ->
    case [mod_offline, mod_offline_odbc] -- gen_mod:loaded_modules(Server) of
        [mod_offline, mod_offline_odbc] -> none;
        [mod_offline_odbc] -> mod_offline;
        [mod_offline] -> mod_offline_odbc
    end.

get_lastactivity_module(Server) ->
    case lists:member(mod_last, gen_mod:loaded_modules(Server)) of
        true -> mod_last;
        _ -> mod_last_odbc
    end.

get_lastactivity_menuitem_list(Server) ->
    case get_lastactivity_module(Server) of
        mod_last -> [{"last-activity", "Last Activity"}];
        mod_last_odbc -> []
    end.

us_to_list({User, Server}) ->
    jlib:jid_to_string({User, Server, ""}).

su_to_list({Server, User}) ->
    jlib:jid_to_string({User, Server, ""}).

%%%==================================
%%%% get_stats

get_stats(global, Lang) ->
    OnlineUsers = mnesia:table_info(session, size),
    RegisteredUsers = lists:foldl(
	fun(Host, Total) ->
	    ejabberd_auth:get_vh_registered_users_number(Host) + Total
	end, 0, ejabberd_config:get_global_option(hosts)),
    S2SConns = ejabberd_s2s:dirty_get_connections(),
    S2SConnections = length(S2SConns),
    S2SServers = length(lists:usort([element(2, C) || C <- S2SConns])),
    [?XAE("table", [],
	  [?XE("tbody",
	       [?XE("tr", [?XCT("td", "Registered Users:"),
			   ?XC("td", pretty_string_int(RegisteredUsers))]),
		?XE("tr", [?XCT("td", "Online Users:"),
			   ?XC("td", pretty_string_int(OnlineUsers))]),
		?XE("tr", [?XCT("td", "Outgoing s2s Connections:"),
			   ?XC("td", pretty_string_int(S2SConnections))]),
		?XE("tr", [?XCT("td", "Outgoing s2s Servers:"),
			   ?XC("td", pretty_string_int(S2SServers))])
	       ])
	  ])];

get_stats(Host, Lang) ->
    OnlineUsers = length(ejabberd_sm:get_vh_session_list(Host)),
    RegisteredUsers = ejabberd_auth:get_vh_registered_users_number(Host),
    [?XAE("table", [],
	  [?XE("tbody",
	       [?XE("tr", [?XCT("td", "Registered Users:"),
			   ?XC("td", pretty_string_int(RegisteredUsers))]),
		?XE("tr", [?XCT("td", "Online Users:"),
			   ?XC("td", pretty_string_int(OnlineUsers))])
	       ])
	  ])].


list_online_users(Host, _Lang) ->
    Users = [{S, U} || {U, S, _R} <- ejabberd_sm:get_vh_session_list(Host)],
    SUsers = lists:usort(Users),
    lists:flatmap(
      fun({_S, U} = SU) ->
	      [?AC("../user/" ++ ejabberd_http:url_encode(U) ++ "/",
		   su_to_list(SU)),
	       ?BR]
      end, SUsers).

user_info(User, Server, Query, Lang) ->
    LServer = jlib:nameprep(Server),
    US = {jlib:nodeprep(User), LServer},
    Res = user_parse_query(User, Server, Query),
    Resources = ejabberd_sm:get_user_resources(User, Server),
    FResources =
	case Resources of
	    [] ->
		[?CT("None")];
	    _ ->
		[?XE("ul",
		     lists:map(fun(R) ->
				       FIP = case ejabberd_sm:get_user_info(
						    User, Server, R) of
						 offline ->
						     "";
						 Info when is_list(Info) ->
						     Node = proplists:get_value(node, Info),
						     Conn = proplists:get_value(conn, Info),
						     {IP, Port} = proplists:get_value(ip, Info),
						     ConnS = case Conn of
								 c2s -> "plain";
								 c2s_tls -> "tls";
								 c2s_compressed -> "zlib";
								 c2s_compressed_tls -> "tls+zlib";
								 http_bind -> "http-bind";
								 http_poll -> "http-poll"
							     end,
						     " (" ++
						         ConnS ++ "://" ++
							 inet_parse:ntoa(IP) ++
							 ":" ++
							 integer_to_list(Port)
						         ++ "#" ++ atom_to_list(Node)
							 ++ ")"
					     end,
				       ?LI([?C(R ++ FIP)])
			       end, lists:sort(Resources)))]
	end,
    Password = ejabberd_auth:get_password_s(User, Server),
    FPassword = [?INPUT("password", "password", Password), ?C(" "),
		 ?INPUTT("submit", "chpassword", "Change Password")],
    UserItems = ejabberd_hooks:run_fold(webadmin_user, LServer, [],
					[User, Server, Lang]),
    %% Code copied from list_given_users/5:
    ModLast = get_lastactivity_module(Server),
    LastActivity = case ejabberd_sm:get_user_resources(User, Server) of
		       [] ->
			   case ModLast:get_last_info(User, Server) of
			       not_found ->
				   ?T("Never");
			       {ok, Shift, _Status} ->
				   TimeStamp = {Shift div 1000000,
						Shift rem 1000000,
						0},
				   {{Year, Month, Day}, {Hour, Minute, Second}} =
				       calendar:now_to_local_time(TimeStamp),
				   lists:flatten(
				     io_lib:format(
				       "~w-~.2.0w-~.2.0w ~.2.0w:~.2.0w:~.2.0w",
				       [Year, Month, Day, Hour, Minute, Second]))
			   end;
		       _ ->
			   ?T("Online")
		   end,
    [?XC("h1", ?T("User ") ++ us_to_list(US))] ++
	case Res of
	    ok -> [?XREST("Submitted")];
	    error -> [?XREST("Bad format")];
	    nothing -> []
	end ++
	[?XAE("form", [{"action", ""}, {"method", "post"}],
	      [?XCT("h3", "Connected Resources:")] ++ FResources ++
	      [?XCT("h3", "Password:")] ++ FPassword ++
	      [?XCT("h3", "Last Activity")] ++ [?C(LastActivity)] ++
	      UserItems ++
	      [?P, ?INPUTT("submit", "removeuser", "Remove User")])].


user_parse_query(User, Server, Query) ->
    lists:foldl(fun({Action, _Value}, Acc) when Acc == nothing ->
                      user_parse_query1(Action, User, Server, Query);
                   ({_Action, _Value}, Acc) ->
                      Acc
                end, nothing, Query).

user_parse_query1("password", _User, _Server, _Query) ->
    nothing;
user_parse_query1("chpassword", User, Server, Query) ->
    case lists:keysearch("password", 1, Query) of
        {value, {_, undefined}} ->
            error;
        {value, {_, Password}} ->
            ejabberd_auth:set_password(User, Server, Password),
            ok;
        _ ->
            error
    end;
user_parse_query1("removeuser", User, Server, _Query) ->
    ejabberd_auth:remove_user(User, Server),
    ok;
user_parse_query1(Action, User, Server, Query) ->
    case ejabberd_hooks:run_fold(webadmin_user_parse_query, Server, [], [Action, User, Server, Query]) of
         [] -> nothing;
         Res -> Res
    end.



list_last_activity(Host, Lang, Integral, Period) ->
    {MegaSecs, Secs, _MicroSecs} = now(),
    TimeStamp = MegaSecs * 1000000 + Secs,
    case Period of
	"all" ->
	    TS = 0,
	    Days = infinity;
	"year" ->
	    TS = TimeStamp - 366 * 86400,
	    Days = 366;
	_ ->
	    TS = TimeStamp - 31 * 86400,
	    Days = 31
    end,
    case catch mnesia:dirty_select(
		 last_activity, [{{last_activity, {'_', Host}, '$1', '_'},
				  [{'>', '$1', TS}],
				  [{'trunc', {'/',
					      {'-', TimeStamp, '$1'},
					      86400}}]}]) of
	{'EXIT', _Reason} ->
	    [];
	Vals ->
	    Hist = histogram(Vals, Integral),
	    if
		Hist == [] ->
		    [?CT("No Data")];
		true ->
		    Left = if
			       Days == infinity ->
				   0;
			       true ->
				   Days - length(Hist)
			   end,
		    Tail = if
			       Integral ->
				   lists:duplicate(Left, lists:last(Hist));
			       true ->
				   lists:duplicate(Left, 0)
			   end,
		    Max = lists:max(Hist),
		    [?XAE("ol",
			  [{"id", "lastactivity"}, {"start", "0"}],
			  [?XAE("li",
				[{"style",
				  "width:" ++ integer_to_list(
						trunc(90 * V / Max)) ++ "%;"}],
				[{xmlcdata, pretty_string_int(V)}])
			   || V <- Hist ++ Tail])]
	    end
    end.

histogram(Values, Integral) ->
    histogram(lists:sort(Values), Integral, 0, 0, []).

histogram([H | T], Integral, Current, Count, Hist) when Current == H ->
    histogram(T, Integral, Current, Count + 1, Hist);
	    
histogram([H | _] = Values, Integral, Current, Count, Hist) when Current < H ->
    if
	Integral ->
	    histogram(Values, Integral, Current + 1, Count, [Count | Hist]);
	true ->
	    histogram(Values, Integral, Current + 1, 0, [Count | Hist])
    end;

histogram([], _Integral, _Current, Count, Hist) ->
    if
	Count > 0 ->
	    lists:reverse([Count | Hist]);
	true ->
	    lists:reverse(Hist)
    end.

%%%==================================
%%%% get_nodes

get_nodes(Lang) ->
    RunningNodes = mnesia:system_info(running_db_nodes),
    StoppedNodes = lists:usort(mnesia:system_info(db_nodes) ++
			       mnesia:system_info(extra_db_nodes)) --
	RunningNodes,
    FRN = if
	      RunningNodes == [] ->
		  ?CT("None");
	      true ->
		  ?XE("ul",
		      lists:map(
			fun(N) ->
				S = atom_to_list(N),
				?LI([?AC("../node/" ++ S ++ "/", S)])
			end, lists:sort(RunningNodes)))
	  end,
    FSN = if
	      StoppedNodes == [] ->
		  ?CT("None");
	      true ->
		  ?XE("ul",
		      lists:map(
			fun(N) ->
				S = atom_to_list(N),
				?LI([?C(S)])
			end, lists:sort(StoppedNodes)))
	  end,
    [?XCT("h1", "Nodes"),
     ?XCT("h3", "Running Nodes"),
     FRN,
     ?XCT("h3", "Stopped Nodes"),
     FSN].

search_running_node(SNode) ->
    search_running_node(SNode, mnesia:system_info(running_db_nodes)).

search_running_node(_, []) ->
    false;
search_running_node(SNode, [Node | Nodes]) ->
    case atom_to_list(Node) of
	SNode ->
	    Node;
	_ ->
	    search_running_node(SNode, Nodes)
    end.

get_node(global, Node, [], Query, Lang) ->
    Res = node_parse_query(Node, Query),
    Base = get_base_path(global, Node),
    MenuItems2 = make_menu_items(global, Node, Base, Lang),
    [?XC("h1", ?T("Node ") ++ atom_to_list(Node))] ++
	case Res of
	    ok -> [?XREST("Submitted")];
	    error -> [?XREST("Bad format")];
	    nothing -> []
	end ++
	[?XE("ul",
	     [?LI([?ACT(Base ++ "db/", "Database")]),
	      ?LI([?ACT(Base ++ "backup/", "Backup")]),
	      ?LI([?ACT(Base ++ "ports/", "Listened Ports")]),
	      ?LI([?ACT(Base ++ "stats/", "Statistics")]),
	      ?LI([?ACT(Base ++ "update/", "Update")])
	     ] ++ MenuItems2),
	 ?XAE("form", [{"action", ""}, {"method", "post"}],
	      [?INPUTT("submit", "restart", "Restart"),
	       ?C(" "),
	       ?INPUTT("submit", "stop", "Stop")])
	];

get_node(Host, Node, [], _Query, Lang) ->
    Base = get_base_path(Host, Node),
    MenuItems2 = make_menu_items(Host, Node, Base, Lang),
    [?XC("h1", ?T("Node ") ++ atom_to_list(Node)),
     ?XE("ul",
	 [?LI([?ACT(Base ++ "modules/", "Modules")])] ++ MenuItems2)
    ];

get_node(global, Node, ["db"], Query, Lang) ->
    case rpc:call(Node, mnesia, system_info, [tables]) of
	{badrpc, _Reason} ->
	    [?XCT("h1", "RPC Call Error")];
	Tables ->
	    ResS = case node_db_parse_query(Node, Tables, Query) of
		       nothing -> [];
		       ok -> [?XREST("Submitted")]
		   end,
	    STables = lists:sort(Tables),
	    Rows = lists:map(
		     fun(Table) ->
			     STable = atom_to_list(Table),
			     TInfo =
				 case rpc:call(Node,
					       mnesia,
					       table_info,
					       [Table, all]) of
				     {badrpc, _} ->
					 [];
				     I ->
					 I
				 end,
			     {Type, Size, Memory} =
				 case {lists:keysearch(storage_type, 1, TInfo),
				       lists:keysearch(size, 1, TInfo),
				       lists:keysearch(memory, 1, TInfo)} of
				     {{value, {storage_type, T}},
				      {value, {size, S}},
				      {value, {memory, M}}} ->
					 {T, S, M};
				     _ ->
					 {unknown, 0, 0}
				 end,
			     ?XE("tr",
				 [?XC("td", STable),
				  ?XE("td", [db_storage_select(
					       STable, Type, Lang)]),
				  ?XAC("td", [{"class", "alignright"}],
					pretty_string_int(Size)),
				  ?XAC("td", [{"class", "alignright"}],
					pretty_string_int(Memory))
				 ])
		     end, STables),
	    [?XC("h1", ?T("Database Tables at ") ++ atom_to_list(Node))] ++
		ResS ++
		[?XAE("form", [{"action", ""}, {"method", "post"}],
		      [?XAE("table", [],
			    [?XE("thead",
				 [?XE("tr",
				      [?XCT("td", "Name"),
				       ?XCT("td", "Storage Type"),
				       ?XCT("td", "Elements"), %% Elements/items/records inserted in the table
				       ?XCT("td", "Memory") %% Words or Bytes allocated to the table on this node
				      ])]),
			     ?XE("tbody",
				 Rows ++
				 [?XE("tr",
				      [?XAE("td", [{"colspan", "4"},
						   {"class", "alignright"}],
					    [?INPUTT("submit", "submit",
						     "Submit")])
				      ])]
				)])])]
    end;

get_node(global, Node, ["backup"], Query, Lang) ->
    HomeDirRaw = case {os:getenv("HOME"), os:type()} of
	{EnvHome, _} when is_list(EnvHome) -> EnvHome;
	{false, {win32, _Osname}} -> "C:/";
	{false, _} -> "/tmp/"
    end,
    HomeDir = filename:nativename(HomeDirRaw),
    ResS = case node_backup_parse_query(Node, Query) of
	       nothing -> [];
	       ok -> [?XREST("Submitted")];
	       {error, Error} -> [?XRES(?T("Error") ++": " ++ io_lib:format("~p", [Error]))]
	   end,
    ?H1GL(?T("Backup of ") ++ atom_to_list(Node), "list-eja-commands", "List of ejabberd Commands") ++
	ResS ++
	[?XCT("p", "Please note that these options will only backup the builtin Mnesia database. If you are using the ODBC module, you also need to backup your SQL database separately."),
     ?XAE("form", [{"action", ""}, {"method", "post"}],
	  [?XAE("table", [],
		[?XE("tbody",
		     [?XE("tr",
 			  [?XCT("td", "Store binary backup:"),
			   ?XE("td", [?INPUT("text", "storepath",
 					     filename:join(HomeDir, "ejabberd.backup"))]),
			   ?XE("td", [?INPUTT("submit", "store",
					      "OK")])
			  ]),
		      ?XE("tr",
 			  [?XCT("td", "Restore binary backup immediately:"),
			   ?XE("td", [?INPUT("text", "restorepath",
 					     filename:join(HomeDir, "ejabberd.backup"))]),
			   ?XE("td", [?INPUTT("submit", "restore",
					      "OK")])
			  ]),
		      ?XE("tr",
			  [?XCT("td",
				"Restore binary backup after next ejabberd restart (requires less memory):"),
			   ?XE("td", [?INPUT("text", "fallbackpath",
 					     filename:join(HomeDir, "ejabberd.backup"))]),
			   ?XE("td", [?INPUTT("submit", "fallback",
					      "OK")])
			  ]),
		      ?XE("tr",
			  [?XCT("td", "Store plain text backup:"),
			   ?XE("td", [?INPUT("text", "dumppath",
 					     filename:join(HomeDir, "ejabberd.dump"))]),
			   ?XE("td", [?INPUTT("submit", "dump",
					      "OK")])
			  ]),
		      ?XE("tr",
			  [?XCT("td", "Restore plain text backup immediately:"),
			   ?XE("td", [?INPUT("text", "loadpath",
 					     filename:join(HomeDir, "ejabberd.dump"))]),
			   ?XE("td", [?INPUTT("submit", "load",
					      "OK")])
 			  ]),
 		      ?XE("tr",
 			  [?XCT("td", "Import users data from a PIEFXIS file (XEP-0227):"),
 			   ?XE("td", [?INPUT("text", "import_piefxis_filepath",
 					     filename:join(HomeDir, "users.xml"))]),
 			   ?XE("td", [?INPUTT("submit", "import_piefxis_file",
 					      "OK")])
 			  ]),
 		      ?XE("tr",
 			  [?XCT("td", "Export data of all users in the server to PIEFXIS files (XEP-0227):"),
 			   ?XE("td", [?INPUT("text", "export_piefxis_dirpath",
 					     HomeDir)]),
 			   ?XE("td", [?INPUTT("submit", "export_piefxis_dir",
 					      "OK")])
 			  ]),
 		      ?XE("tr",
 			  [?XE("td", [?CT("Export data of users in a host to PIEFXIS files (XEP-0227):"),
 			              ?C(" "),
 			              ?INPUT("text", "export_piefxis_host_dirhost", ?MYNAME)]),
 			   ?XE("td", [?INPUT("text", "export_piefxis_host_dirpath", HomeDir)]),
 			   ?XE("td", [?INPUTT("submit", "export_piefxis_host_dir",
 					      "OK")])
 			  ]),
 		      ?XE("tr",
 			  [?XCT("td", "Import user data from jabberd14 spool file:"),
 			   ?XE("td", [?INPUT("text", "import_filepath",
 					     filename:join(HomeDir, "user1.xml"))]),
 			   ?XE("td", [?INPUTT("submit", "import_file",
 					      "OK")])
 			  ]),
 		      ?XE("tr",
 			  [?XCT("td", "Import users data from jabberd14 spool directory:"),
 			   ?XE("td", [?INPUT("text", "import_dirpath",
 					     "/var/spool/jabber/")]),
 			   ?XE("td", [?INPUTT("submit", "import_dir",
 					      "OK")])
			  ])
		     ])
		])])];

get_node(global, Node, ["ports"], Query, Lang) ->
    Ports = rpc:call(Node, ejabberd_config, get_local_option, [listen]),
    Res = case catch node_ports_parse_query(Node, Ports, Query) of
	      submitted ->
		  ok;
	      {'EXIT', _Reason} ->
		  error;
	      {is_added, ok} ->
		  ok;
	      {is_added, {error, Reason}} ->
		  {error, io_lib:format("~p", [Reason])};
	      _ ->
		  nothing
	  end,
    %% TODO: This sorting does not work when [{{Port, IP}, Module, Opts}]
    NewPorts = lists:sort(
		 rpc:call(Node, ejabberd_config, get_local_option, [listen])),
    H1String = ?T("Listened Ports at ") ++ atom_to_list(Node),
    ?H1GL(H1String, "listened", "Listening Ports") ++
	case Res of
	    ok -> [?XREST("Submitted")];
	    error -> [?XREST("Bad format")];
	    {error, ReasonT} -> [?XRES(?T("Error") ++ ": " ++ ReasonT)];
	    nothing -> []
	end ++
	[?XAE("form", [{"action", ""}, {"method", "post"}],
	      [node_ports_to_xhtml(NewPorts, Lang)])
	];

get_node(Host, Node, ["modules"], Query, Lang) when is_list(Host) ->
    Modules = rpc:call(Node, gen_mod, loaded_modules_with_opts, [Host]),
    Res = case catch node_modules_parse_query(Host, Node, Modules, Query) of
	      submitted ->
		  ok;
	      {'EXIT', Reason} ->
		  ?INFO_MSG("~p~n", [Reason]),
		  error;
	      _ ->
		  nothing
	  end,
    NewModules = lists:sort(
		   rpc:call(Node, gen_mod, loaded_modules_with_opts, [Host])),
    H1String = ?T("Modules at ") ++ atom_to_list(Node),
    ?H1GL(H1String, "modoverview", "Modules Overview") ++
	case Res of
	    ok -> [?XREST("Submitted")];
	    error -> [?XREST("Bad format")];
	    nothing -> []
	end ++
	[?XAE("form", [{"action", ""}, {"method", "post"}],
	      [node_modules_to_xhtml(NewModules, Lang)])
	];

get_node(global, Node, ["stats"], _Query, Lang) ->
    UpTime = rpc:call(Node, erlang, statistics, [wall_clock]),
    UpTimeS = io_lib:format("~.3f", [element(1, UpTime)/1000]),
    CPUTime = rpc:call(Node, erlang, statistics, [runtime]),
    CPUTimeS = io_lib:format("~.3f", [element(1, CPUTime)/1000]),
    OnlineUsers = mnesia:table_info(session, size),
    TransactionsCommitted =
	rpc:call(Node, mnesia, system_info, [transaction_commits]),
    TransactionsAborted =
	rpc:call(Node, mnesia, system_info, [transaction_failures]),
    TransactionsRestarted =
	rpc:call(Node, mnesia, system_info, [transaction_restarts]),
    TransactionsLogged =
	rpc:call(Node, mnesia, system_info, [transaction_log_writes]),
    
    [?XC("h1", io_lib:format(?T("Statistics of ~p"), [Node])),
     ?XAE("table", [],
	  [?XE("tbody",
	       [?XE("tr", [?XCT("td", "Uptime:"),
			   ?XAC("td", [{"class", "alignright"}],
				UpTimeS)]),
		?XE("tr", [?XCT("td", "CPU Time:"),
			   ?XAC("td", [{"class", "alignright"}],
				CPUTimeS)]),
		?XE("tr", [?XCT("td", "Online Users:"),
			   ?XAC("td", [{"class", "alignright"}],
				pretty_string_int(OnlineUsers))]),
		?XE("tr", [?XCT("td", "Transactions Committed:"),
			   ?XAC("td", [{"class", "alignright"}],
				pretty_string_int(TransactionsCommitted))]),
		?XE("tr", [?XCT("td", "Transactions Aborted:"),
			   ?XAC("td", [{"class", "alignright"}],
				pretty_string_int(TransactionsAborted))]),
		?XE("tr", [?XCT("td", "Transactions Restarted:"),
			   ?XAC("td", [{"class", "alignright"}],
				pretty_string_int(TransactionsRestarted))]),
		?XE("tr", [?XCT("td", "Transactions Logged:"),
			   ?XAC("td", [{"class", "alignright"}],
				pretty_string_int(TransactionsLogged))])
	       ])
	  ])];

get_node(global, Node, ["update"], Query, Lang) ->
    rpc:call(Node, code, purge, [ejabberd_update]),
    Res = node_update_parse_query(Node, Query),
    rpc:call(Node, code, load_file, [ejabberd_update]),
    {ok, _Dir, UpdatedBeams, Script, LowLevelScript, Check} =
	rpc:call(Node, ejabberd_update, update_info, []),
    Mods =
	case UpdatedBeams of
	    [] ->
		?CT("None");
	    _ ->
		BeamsLis =
		    lists:map(
		      fun(Beam) ->
			      BeamString = atom_to_list(Beam),
			      ?LI([
				   ?INPUT("checkbox", "selected", BeamString),
				   %%?XA("input", [{"checked", ""}, %% Selected by default
					%%	 {"type", "checkbox"},
					%%	 {"name", "selected"},
					%%	 {"value", BeamString}]),
				   ?C(BeamString)])
		      end,
		      UpdatedBeams),
		SelectButtons =
		    [?BR,
		     ?INPUTATTRS("button", "selectall", "Select All",
				 [{"onClick", "selectAll()"}]),
		     ?C(" "),
		     ?INPUTATTRS("button", "unselectall", "Unselect All",
				 [{"onClick", "unSelectAll()"}])],
		%%?XE("ul", BeamsLis)
		?XAE("ul", [{"class", "nolistyle"}], BeamsLis ++ SelectButtons)
	end,
    FmtScript = ?XC("pre", io_lib:format("~p", [Script])),
    FmtLowLevelScript = ?XC("pre", io_lib:format("~p", [LowLevelScript])),
    [?XC("h1", ?T("Update ") ++ atom_to_list(Node))] ++
	case Res of
	    ok -> [?XREST("Submitted")];
	    {error, ErrorText} -> [?XREST("Error: " ++ ErrorText)];
	    nothing -> []
	end ++
	[?XAE("form", [{"action", ""}, {"method", "post"}],
	      [
	       ?XCT("h2", "Update plan"),
	       ?XCT("h3", "Modified modules"), Mods,
	       ?XCT("h3", "Update script"), FmtScript,
	       ?XCT("h3", "Low level update script"), FmtLowLevelScript,
	       ?XCT("h3", "Script check"), ?XC("pre", atom_to_list(Check)),
	       ?BR,
	       ?INPUTT("submit", "update", "Update")
	      ])
	];

get_node(Host, Node, NPath, Query, Lang) ->
    {Hook, Opts} = case Host of
		       global -> {webadmin_page_node, [Node, NPath, Query, Lang]};
		       Host -> {webadmin_page_hostnode, [Host, Node, NPath, Query, Lang]}
		   end,
    case ejabberd_hooks:run_fold(Hook, Host, [], Opts) of
	[] -> [?XC("h1", "Not Found")];
	Res -> Res
    end.

%%%==================================
%%%% node parse

node_parse_query(Node, Query) ->
    case lists:keysearch("restart", 1, Query) of
	{value, _} ->
	    case rpc:call(Node, init, restart, []) of
		{badrpc, _Reason} ->
		    error;
		_ ->
		    ok
	    end;
	_ ->
	    case lists:keysearch("stop", 1, Query) of
		{value, _} ->
		    case rpc:call(Node, init, stop, []) of
			{badrpc, _Reason} ->
			    error;
			_ ->
			    ok
		    end;
		_ ->
		    nothing
	    end
    end.


db_storage_select(ID, Opt, Lang) ->
    ?XAE("select", [{"name", "table" ++ ID}],
	 lists:map(
	   fun({O, Desc}) ->
		   Sel = if
			     O == Opt -> [{"selected", "selected"}];
			     true -> []
			 end,
		   ?XACT("option",
			 Sel ++ [{"value", atom_to_list(O)}],
			 Desc)
	   end, [{ram_copies, "RAM copy"},
		 {disc_copies, "RAM and disc copy"},
		 {disc_only_copies, "Disc only copy"},
		 {unknown, "Remote copy"},
		 {delete_content, "Delete content"},
		 {delete_table, "Delete table"}])).

node_db_parse_query(_Node, _Tables, [{nokey,[]}]) ->
    nothing;
node_db_parse_query(Node, Tables, Query) ->
    lists:foreach(
      fun(Table) ->
	      STable = atom_to_list(Table),
	      case lists:keysearch("table" ++ STable, 1, Query) of
		  {value, {_, SType}} ->
		      Type = case SType of
				 "unknown" -> unknown;
				 "ram_copies" -> ram_copies;
				 "disc_copies" -> disc_copies;
				 "disc_only_copies" -> disc_only_copies;
				 "delete_content" -> delete_content;
				 "delete_table" -> delete_table;
				 _ -> false
			     end,
		      if
			  Type == false ->
			      ok;
			  Type == delete_content ->
			      mnesia:clear_table(Table);
			  Type == delete_table ->
			      mnesia:delete_table(Table);
			  Type == unknown ->
			      mnesia:del_table_copy(Table, Node);
			  true ->
			      case mnesia:add_table_copy(Table, Node, Type) of
				  {aborted, _} ->
				      mnesia:change_table_copy_type(
					Table, Node, Type);
				  _ ->
				      ok
			      end
		      end;
		  _ ->
		      ok
	      end
      end, Tables),
    ok.

node_backup_parse_query(_Node, [{nokey,[]}]) ->
    nothing;
node_backup_parse_query(Node, Query) ->
    lists:foldl(
      fun(Action, nothing) ->
	      case lists:keysearch(Action, 1, Query) of
		  {value, _} ->
		      case lists:keysearch(Action ++ "path", 1, Query) of
			  {value, {_, Path}} ->
			      Res =
				  case Action of
				      "store" ->
					  rpc:call(Node, mnesia,
						   backup, [Path]);
				      "restore" ->
					  rpc:call(Node, ejabberd_admin,
						   restore, [Path]);
				      "fallback" ->
					  rpc:call(Node, mnesia,
						   install_fallback, [Path]);
				      "dump" ->
					  rpc:call(Node, ejabberd_admin,
						   dump_to_textfile, [Path]);
				      "load" ->
					  rpc:call(Node, mnesia,
						   load_textfile, [Path]);
				      "import_piefxis_file" ->
					  rpc:call(Node, ejabberd_piefxis,
						   import_file, [Path]);
				      "export_piefxis_dir" ->
					  rpc:call(Node, ejabberd_piefxis,
						   export_server, [Path]);
				      "export_piefxis_host_dir" ->
					  {value, {_, Host}} = lists:keysearch(Action ++ "host", 1, Query),
					  rpc:call(Node, ejabberd_piefxis,
						   export_host, [Path, Host]);
				      "import_file" ->
					  rpc:call(Node, ejabberd_admin,
						   import_file, [Path]);
				      "import_dir" ->
					  rpc:call(Node, ejabberd_admin,
						   import_dir, [Path])
				  end,
			      case Res of
				  {error, Reason} ->
				      {error, Reason};
				  {badrpc, Reason} ->
				      {badrpc, Reason};
				  _ ->
				      ok
			      end;
			  OtherError ->
			      {error, OtherError}
		      end;
		  _ ->
		      nothing
	      end;
	 (_Action, Res) ->
	      Res
      end, nothing, ["store", "restore", "fallback", "dump", "load", "import_file", "import_dir",
	     "import_piefxis_file", "export_piefxis_dir", "export_piefxis_host_dir"]).

node_ports_to_xhtml(Ports, Lang) ->
    ?XAE("table", [{"class", "withtextareas"}],
	 [?XE("thead",
	      [?XE("tr",
		   [?XCT("td", "Port"),
		    ?XCT("td", "IP"),
		    ?XCT("td", "Protocol"),
		    ?XCT("td", "Module"),
		    ?XCT("td", "Options")
		   ])]),
	  ?XE("tbody",
	      lists:map(
		fun({PortIP, Module, Opts} = _E) ->
			{_Port, SPort, _TIP, SIP, SSPort, NetProt, OptsClean} =
			    get_port_data(PortIP, Opts),
			SModule = atom_to_list(Module),
			{NumLines, SOptsClean} = term_to_paragraph(OptsClean, 40),
			%%ID = term_to_id(E),
			?XE("tr",
			    [?XAE("td", [{"size", "6"}], [?C(SPort)]),
			     ?XAE("td", [{"size", "15"}], [?C(SIP)]),
			     ?XAE("td", [{"size", "4"}], [?C(atom_to_list(NetProt))]),
			     ?XE("td", [?INPUTS("text", "module" ++ SSPort,
						SModule, "15")]),
			     ?XE("td", [?TEXTAREA("opts" ++ SSPort, integer_to_list(NumLines), "35", SOptsClean)]),
			     ?XE("td", [?INPUTT("submit", "add" ++ SSPort,
						"Update")]),
			     ?XE("td", [?INPUTT("submit", "delete" ++ SSPort,
						"Delete")])
			    ]
			   )
		end, Ports) ++
	      [?XE("tr",
		   [?XE("td", [?INPUTS("text", "portnew", "", "6")]),
		    ?XE("td", [?INPUTS("text", "ipnew", "0.0.0.0", "15")]),
		    ?XE("td", [make_netprot_html("tcp")]),
		    ?XE("td", [?INPUTS("text", "modulenew", "", "15")]),
		    ?XE("td", [?TEXTAREA("optsnew", "2", "35", "[]")]),
		    ?XAE("td", [{"colspan", "2"}],
			 [?INPUTT("submit", "addnew", "Add New")])
		   ]
		  )]
	     )]).

make_netprot_html(NetProt) ->
    ?XAE("select", [{"name", "netprotnew"}],
	 lists:map(
	   fun(O) ->
		   Sel = if
			     O == NetProt -> [{"selected", "selected"}];
			     true -> []
			 end,
		   ?XAC("option",
			Sel ++ [{"value", O}],
			O)
	   end, ["tcp", "udp"])).

get_port_data(PortIP, Opts) ->
    {Port, IPT, IPS, _IPV, NetProt, OptsClean} = ejabberd_listener:parse_listener_portip(PortIP, Opts),
    SPort = io_lib:format("~p", [Port]),

    SSPort = lists:flatten(
	       lists:map(
		 fun(N) -> io_lib:format("~.16b", [N]) end,
		 binary_to_list(crypto:md5(SPort++IPS++atom_to_list(NetProt))))),
    {Port, SPort, IPT, IPS, SSPort, NetProt, OptsClean}.
  

node_ports_parse_query(Node, Ports, Query) ->
    lists:foreach(
      fun({PortIpNetp, Module1, Opts1}) ->
	      {Port, _SPort, TIP, _SIP, SSPort, NetProt, _OptsClean} =
		  get_port_data(PortIpNetp, Opts1),
	      case lists:keysearch("add" ++ SSPort, 1, Query) of
		  {value, _} ->
		      PortIpNetp2 = {Port, TIP, NetProt},
		      {{value, {_, SModule}}, {value, {_, SOpts}}} =
			  {lists:keysearch("module" ++ SSPort, 1, Query),
			   lists:keysearch("opts" ++ SSPort, 1, Query)},
		      Module = list_to_atom(SModule),
		      {ok, Tokens, _} = erl_scan:string(SOpts ++ "."),
		      {ok, Opts} = erl_parse:parse_term(Tokens),
		      rpc:call(Node, ejabberd_listener, delete_listener,
			       [PortIpNetp2, Module1]),
		      R=rpc:call(Node, ejabberd_listener, add_listener,
				 [PortIpNetp2, Module, Opts]),
		      throw({is_added, R});
		  _ ->
		      case lists:keysearch("delete" ++ SSPort, 1, Query) of
			  {value, _} ->
			      rpc:call(Node, ejabberd_listener, delete_listener,
				       [PortIpNetp, Module1]),
			      throw(submitted);
			  _ ->
			      ok
		      end
	      end
      end, Ports),
    case lists:keysearch("addnew", 1, Query) of
	{value, _} ->
	    {{value, {_, SPort}},
	     {value, {_, STIP}}, %% It is a string that may represent a tuple
	     {value, {_, SNetProt}},
	     {value, {_, SModule}},
	     {value, {_, SOpts}}} =
		{lists:keysearch("portnew", 1, Query),
		 lists:keysearch("ipnew", 1, Query),
		 lists:keysearch("netprotnew", 1, Query),
		 lists:keysearch("modulenew", 1, Query),
		 lists:keysearch("optsnew", 1, Query)},
	    {ok, Toks, _} = erl_scan:string(SPort ++ "."),
	    {ok, Port2} = erl_parse:parse_term(Toks),
	    {ok, ToksIP, _} = erl_scan:string(STIP ++ "."),
	    STIP2 = case erl_parse:parse_term(ToksIP) of
			{ok, IPTParsed} -> IPTParsed;
			{error, _} -> STIP
		    end,
	    Module = list_to_atom(SModule),
	    NetProt2 = list_to_atom(SNetProt),
	    {ok, Tokens, _} = erl_scan:string(SOpts ++ "."),
	    {ok, Opts} = erl_parse:parse_term(Tokens),
	    {Port2, _SPort, IP2, _SIP, _SSPort, NetProt2, OptsClean} =
		get_port_data({Port2, STIP2, NetProt2}, Opts),
	    R=rpc:call(Node, ejabberd_listener, add_listener,
		       [{Port2, IP2, NetProt2}, Module, OptsClean]),
	    throw({is_added, R});
	_ ->
	    ok
    end.

node_modules_to_xhtml(Modules, Lang) ->
    ?XAE("table", [{"class", "withtextareas"}],
	 [?XE("thead",
	      [?XE("tr",
		   [?XCT("td", "Module"),
		    ?XCT("td", "Options")
		   ])]),
	  ?XE("tbody",
	      lists:map(
		fun({Module, Opts} = _E) ->
			SModule = atom_to_list(Module),
			{NumLines, SOpts} = term_to_paragraph(Opts, 40),
			%%ID = term_to_id(E),
			?XE("tr",
			    [?XC("td", SModule),
			     ?XE("td", [?TEXTAREA("opts" ++ SModule, integer_to_list(NumLines), "40", SOpts)]),
			     ?XE("td", [?INPUTT("submit", "restart" ++ SModule,
						"Restart")]),
			     ?XE("td", [?INPUTT("submit", "stop" ++ SModule,
						"Stop")])
			    ]
			   )
		end, Modules) ++
	      [?XE("tr",
		   [?XE("td", [?INPUT("text", "modulenew", "")]),
		    ?XE("td", [?TEXTAREA("optsnew", "2", "40", "[]")]),
		    ?XAE("td", [{"colspan", "2"}],
			 [?INPUTT("submit", "start", "Start")])
		   ]
		  )]
	     )]).

node_modules_parse_query(Host, Node, Modules, Query) ->
    lists:foreach(
      fun({Module, _Opts1}) ->
	      SModule = atom_to_list(Module),
	      case lists:keysearch("restart" ++ SModule, 1, Query) of
		  {value, _} ->
		      {value, {_, SOpts}} =
			   lists:keysearch("opts" ++ SModule, 1, Query),
		      {ok, Tokens, _} = erl_scan:string(SOpts ++ "."),
		      {ok, Opts} = erl_parse:parse_term(Tokens),
		      rpc:call(Node, gen_mod, stop_module, [Host, Module]),
		      rpc:call(Node, gen_mod, start_module, [Host, Module, Opts]),
		      throw(submitted);
		  _ ->
		      case lists:keysearch("stop" ++ SModule, 1, Query) of
			  {value, _} ->
			      rpc:call(Node, gen_mod, stop_module, [Host, Module]),
			      throw(submitted);
			  _ ->
			      ok
		      end
	      end
      end, Modules),
    case lists:keysearch("start", 1, Query) of
	{value, _} ->
	    {{value, {_, SModule}},
	     {value, {_, SOpts}}} =
		{lists:keysearch("modulenew", 1, Query),
		 lists:keysearch("optsnew", 1, Query)},
	    Module = list_to_atom(SModule),
	    {ok, Tokens, _} = erl_scan:string(SOpts ++ "."),
	    {ok, Opts} = erl_parse:parse_term(Tokens),
	    rpc:call(Node, gen_mod, start_module, [Host, Module, Opts]),
	    throw(submitted);
	_ ->
	    ok
    end.


node_update_parse_query(Node, Query) ->
    case lists:keysearch("update", 1, Query) of
	{value, _} ->
	    ModulesToUpdateStrings = proplists:get_all_values("selected",Query),
	    ModulesToUpdate = [list_to_atom(M) || M <- ModulesToUpdateStrings],
	    case rpc:call(Node, ejabberd_update, update, [ModulesToUpdate]) of
		{ok, _} ->
		    ok;
		{error, Error} ->
		    ?ERROR_MSG("~p~n", [Error]),
		    {error, io_lib:format("~p", [Error])};
		{badrpc, Error} ->
		    ?ERROR_MSG("Bad RPC: ~p~n", [Error]),
		    {error, "Bad RPC: " ++ io_lib:format("~p", [Error])}
	    end;
	_ ->
	    nothing
    end.


pretty_print_xml(El) ->
    lists:flatten(pretty_print_xml(El, "")).

pretty_print_xml({xmlcdata, CData}, Prefix) ->
    [Prefix, CData, $\n];
pretty_print_xml({xmlelement, Name, Attrs, Els}, Prefix) ->
    [Prefix, $<, Name,
     case Attrs of
	 [] ->
	     [];
	 [{Attr, Val} | RestAttrs] ->
	     AttrPrefix = [Prefix,
			   string:copies(" ", length(Name) + 2)],
	     [$\s, Attr, $=, $', xml:crypt(Val), $' |
	      lists:map(fun({Attr1, Val1}) ->
				[$\n, AttrPrefix,
				 Attr1, $=, $', xml:crypt(Val1), $']
			end, RestAttrs)]
     end,
     if
	 Els == [] ->
	     "/>\n";
	 true ->
	     OnlyCData = lists:all(fun({xmlcdata, _}) -> true;
				      ({xmlelement, _, _, _}) -> false
				   end, Els),
	     if
		 OnlyCData ->
		     [$>,
		      xml:get_cdata(Els),
		      $<, $/, Name, $>, $\n
		     ];
		 true ->
		     [$>, $\n,
		      lists:map(fun(E) ->
					pretty_print_xml(E, [Prefix, "  "])
				end, Els),
		      Prefix, $<, $/, Name, $>, $\n
		     ]
	     end
     end].

element_to_list(X) when is_atom(X) -> atom_to_list(X);
element_to_list(X) when is_integer(X) -> integer_to_list(X).

list_to_element(List) ->
    {ok, Tokens, _} = erl_scan:string(List),
    [{_, _, Element}] = Tokens,
    Element.

url_func({user_diapason, From, To}) ->
    integer_to_list(From) ++ "-" ++ integer_to_list(To) ++ "/";
url_func({users_queue, Prefix, User, _Server}) ->
    Prefix ++ "user/" ++ User ++ "/queue/";
url_func({user, Prefix, User, _Server}) ->
    Prefix ++ "user/" ++ User ++ "/".

last_modified() ->
    {"Last-Modified", "Mon, 25 Feb 2008 13:23:30 GMT"}.
cache_control_public() ->
    {"Cache-Control", "public"}.

%% Transform 1234567890 into "1,234,567,890"
pretty_string_int(Integer) when is_integer(Integer) ->
    pretty_string_int(integer_to_list(Integer));
pretty_string_int(String) when is_list(String) ->
    {_, Result} = lists:foldl(
		    fun(NewNumber, {3, Result}) ->
			    {1, [NewNumber, $, | Result]};
		       (NewNumber, {CountAcc, Result}) ->
			    {CountAcc+1, [NewNumber | Result]}
		    end,
		    {0, ""},
		    lists:reverse(String)),
    Result.

%%%==================================
%%%% navigation menu

%% @spec (Host, Node, Lang, JID::jid()) -> [LI]
make_navigation(Host, Node, Lang, JID) ->
    Menu = make_navigation_menu(Host, Node, Lang, JID),
    make_menu_items(Lang, Menu).

%% @spec (Host, Node, Lang, JID::jid()) -> Menu
%% where Host = global | string()
%%       Node = cluster | string()
%%       Lang = string()
%%       Menu = {URL, Title} | {URL, Title, [Menu]}
%%       URL = string()
%%       Title = string()
make_navigation_menu(Host, Node, Lang, JID) ->
    HostNodeMenu = make_host_node_menu(Host, Node, Lang, JID),
    HostMenu = make_host_menu(Host, HostNodeMenu, Lang, JID),
    NodeMenu = make_node_menu(Host, Node, Lang),
    make_server_menu(HostMenu, NodeMenu, Lang, JID).

%% @spec (Host, Node, Base, Lang) -> [LI]
make_menu_items(global, cluster, Base, Lang) ->
    HookItems = get_menu_items_hook(server, Lang),
    make_menu_items(Lang, {Base, "", HookItems});

make_menu_items(global, Node, Base, Lang) ->
    HookItems = get_menu_items_hook({node, Node}, Lang),
    make_menu_items(Lang, {Base, "", HookItems});

make_menu_items(Host, cluster, Base, Lang) ->
    HookItems = get_menu_items_hook({host, Host}, Lang),
    make_menu_items(Lang, {Base, "", HookItems});

make_menu_items(Host, Node, Base, Lang) ->
    HookItems = get_menu_items_hook({hostnode, Host, Node}, Lang),
    make_menu_items(Lang, {Base, "", HookItems}).


make_host_node_menu(global, _, _Lang, _JID) ->
    {"", "", []};
make_host_node_menu(_, cluster, _Lang, _JID) ->
    {"", "", []};
make_host_node_menu(Host, Node, Lang, JID) ->
    HostNodeBase = get_base_path(Host, Node),
    HostNodeFixed = [{"modules/", "Modules"}]
    ++ get_menu_items_hook({hostnode, Host, Node}, Lang),
    HostNodeBasePath = url_to_path(HostNodeBase),
    HostNodeFixed2 = [Tuple || Tuple <- HostNodeFixed, is_allowed_path(HostNodeBasePath, Tuple, JID)],
    {HostNodeBase, atom_to_list(Node), HostNodeFixed2}.

make_host_menu(global, _HostNodeMenu, _Lang, _JID) ->
    {"", "", []};
make_host_menu(Host, HostNodeMenu, Lang, JID) ->
    HostBase = get_base_path(Host, cluster),
    HostFixed = [{"acls", "Access Control Lists"},
		 {"access", "Access Rules"},
		 {"users", "Users"},
		 {"online-users", "Online Users"}]
		++ get_lastactivity_menuitem_list(Host) ++
		[{"nodes", "Nodes", HostNodeMenu},
		 {"stats", "Statistics"}]
	++ get_menu_items_hook({host, Host}, Lang),
    HostBasePath = url_to_path(HostBase),
    HostFixed2 = [Tuple || Tuple <- HostFixed, is_allowed_path(HostBasePath, Tuple, JID)],
    {HostBase, Host, HostFixed2}.

make_node_menu(_Host, cluster, _Lang) ->
    {"", "", []};
make_node_menu(global, Node, Lang) ->
    NodeBase = get_base_path(global, Node),
    NodeFixed = [{"db/", "Database"},
		 {"backup/", "Backup"},
		 {"ports/", "Listened Ports"},
		 {"stats/", "Statistics"},
		 {"update/", "Update"}]
	++ get_menu_items_hook({node, Node}, Lang),
    {NodeBase, atom_to_list(Node), NodeFixed};
make_node_menu(_Host, _Node, _Lang) ->
    {"", "", []}.

make_server_menu(HostMenu, NodeMenu, Lang, JID) ->
    Base = get_base_path(global, cluster),
    Fixed = [{"acls", "Access Control Lists"},
	     {"access", "Access Rules"},
	     {"vhosts", "Virtual Hosts", HostMenu},
	     {"nodes", "Nodes", NodeMenu},
	     {"stats", "Statistics"}]
	++ get_menu_items_hook(server, Lang),
    BasePath = url_to_path(Base),
    Fixed2 = [Tuple || Tuple <- Fixed, is_allowed_path(BasePath, Tuple, JID)],
    {Base, "ejabberd", Fixed2}.


get_menu_items_hook({hostnode, Host, Node}, Lang) ->
    ejabberd_hooks:run_fold(webadmin_menu_hostnode, Host, [], [Host, Node, Lang]);
get_menu_items_hook({host, Host}, Lang) ->
    ejabberd_hooks:run_fold(webadmin_menu_host, Host, [], [Host, Lang]);
get_menu_items_hook({node, Node}, Lang) ->
    ejabberd_hooks:run_fold(webadmin_menu_node, [], [Node, Lang]);
get_menu_items_hook(server, Lang) ->
    ejabberd_hooks:run_fold(webadmin_menu_main, [], [Lang]).


%% @spec (Lang::string(), Menu) -> [LI]
%% where Menu = {MURI::string(), MName::string(), Items::[Item]}
%%       Item = {IURI::string(), IName::string()} | {IURI::string(), IName::string(), Menu}
make_menu_items(Lang, Menu) ->
    lists:reverse(make_menu_items2(Lang, 1, Menu)).

make_menu_items2(Lang, Deep, {MURI, MName, _} = Menu) ->
    Res = case MName of
	      "" -> [];
	      _ -> [make_menu_item(header, Deep, MURI, MName, Lang) ]
	  end,
    make_menu_items2(Lang, Deep, Menu, Res).

make_menu_items2(_, _Deep, {_, _, []}, Res) ->
    Res;

make_menu_items2(Lang, Deep, {MURI, MName, [Item | Items]}, Res) ->
    Res2 = case Item of
	       {IURI, IName} ->
		   [make_menu_item(item, Deep, MURI++IURI++"/", IName, Lang) | Res];
	       {IURI, IName, SubMenu} ->
		   %%ResTemp = [?LI([?ACT(MURI ++ IURI ++ "/", IName)]) | Res],
		   ResTemp = [make_menu_item(item, Deep, MURI++IURI++"/", IName, Lang) | Res],
		   ResSubMenu = make_menu_items2(Lang, Deep+1, SubMenu),
		   ResSubMenu ++ ResTemp
	   end,
    make_menu_items2(Lang, Deep, {MURI, MName, Items}, Res2).

make_menu_item(header, 1, URI, Name, _Lang) ->
    ?LI([?XAE("div", [{"id", "navhead"}], [?AC(URI, Name)] )]);
make_menu_item(header, 2, URI, Name, _Lang) ->
    ?LI([?XAE("div", [{"id", "navheadsub"}], [?AC(URI, Name)] )]);
make_menu_item(header, 3, URI, Name, _Lang) ->
    ?LI([?XAE("div", [{"id", "navheadsubsub"}], [?AC(URI, Name)] )]);
make_menu_item(item, 1, URI, Name, Lang) ->
    ?LI([?XAE("div", [{"id", "navitem"}], [?ACT(URI, Name)] )]);
make_menu_item(item, 2, URI, Name, Lang) ->
    ?LI([?XAE("div", [{"id", "navitemsub"}], [?ACT(URI, Name)] )]);
make_menu_item(item, 3, URI, Name, Lang) ->
    ?LI([?XAE("div", [{"id", "navitemsubsub"}], [?ACT(URI, Name)] )]).

%%%==================================

%%% vim: set foldmethod=marker foldmarker=%%%%,%%%=: