^if($auth.is_logon){
- ^rem{ *** *** }
+ ^rem{ *** информация о пользователе *** }
- :
- : $auth.user.name
+ Информация о пользователе:
+ Логин: $auth.user.name
Email: $auth.user.email
- : ^auth.user.groups.menu{$auth.user.groups.name}[, ]
- : $auth.user.dt_register
- : $auth.user.dt_logon
+ Состоит в группах: ^auth.user.groups.menu{$auth.user.groups.name}[, ]
+ Дата регистрации: $auth.user.dt_register
+ Дата последнего логина: $auth.user.dt_logon
}{
-
: $auth.last_name
+
Последний раз подключался пользователь: $auth.last_name
}
- ^rem{ *** . *** }
+ ^rem{ *** выводим форму для логаута. если пользователь не залогинен форма показана не будет *** }
^auth.htmlFormLogout[$.target_url[./_auth_info.html]]
}
diff --git a/auth/_auth_profile.html b/auth/_auth_profile.html
index 91b3a82..ada955a 100644
--- a/auth/_auth_profile.html
+++ b/auth/_auth_profile.html
@@ -1,53 +1,53 @@
-# ! !
+# ВНИМАНИЕ! НЕ ЗАБУДЬТЕ УДАЛИТЬ ЭТОТ ФАЙЛ С РАБОЧЕГО САЙТА!
@main[]
-^rem{ *** sql *** }
+^rem{ *** устанавливаем соединение с sql сервером *** }
^oSql.server{
- ^rem{ *** auth. $form:fields -. /logout *** }
+ ^rem{ *** создаем объект класса auth. на этой странице мы не передаем классу $form:fields сл-но. тут логин/logout произойти не может *** }
$auth[^auth::init[$cookie:CLASS;;$.csql[$oSql]]]
- ^rem{ *** *** }
+ ^rem{ *** выдаем антикеширующие заголовки *** }
^auth.setExpireHeaders[]
- <^;<^;
+ <^;<^; Информация о сессии
-
Пользователю Admin успешно установлен пароль $form:code
}
}{
- ^rem{ *** *** }
+ ^rem{ *** показываем форму *** }
$password[^math:md5[^math:random(1000)]]
}
diff --git a/auth/auth.p b/auth/auth.p
index 0d95a67..7e0c71d 100644
--- a/auth/auth.p
+++ b/auth/auth.p
@@ -1,66 +1,66 @@
###########################################################################
# $Id: auth.p,v 1.84 2009-08-22 23:38:28 misha Exp $
#
-# auth
+# КЛАСС auth
#
-# , auth.uid auth.sid
-# auth.uid - ,
-# auth.sid -
-# asession
+# Класс предназначен для установления сессии работы, состояние запоминается в куках auth.uid и auth.sid
+# auth.uid - кука пользователя, которая дается на определенный срок и продляется при каждом новом сеансе работы
+# auth.sid - кука сессии
+# все выданые куки пишутся в таблицу asession
#
-# :
-# $init_type - int,
-# -1 - ,
-# 0 -
-# 1 -
-# 2 - sid sid , sid,
-# 3 - sid uid , , sid, uid, .
-# $status int, . -
-# $session hash,
+# СВОЙСТВА ОБЪЕКТА:
+# $init_type - int, тип инициализации сессии произошел
+# -1 - еще не знаем, включены куки у этого пользователя или нет
+# 0 - продолжение текущей сессии
+# 1 - обновили в базе дату
+# 2 - в базе sid не соответствовало sid в куках, выдали новый sid, обновили базу
+# 3 - sid и uid в базе не соответствовали тому, что в куках, выбрали новый sid, uid, обновили базу.
+# $status int, статус последней операции. сразу после конструирования объекта - результат логина
+# $session hash, информация о текущей сессии
# [ session_id, sid, uid, dt_access, dt_logon, dt_logout ]
-# $groups table,
+# $groups table, информация о всех группах
# [ group_id, name, description, rights, is_default ]
-# $user hash, ,
+# $user hash, параметры пользователя, если он подключен
# [ user_id, name, email, dt_register, dt_logon, dt_logout, rights, event_type, connections_limit, groups ]
-# $is_logon int, (1) (0)
-# $last_name string, ( $icookie_data)
+# $is_logon int, залогинен пользователь (1) или нет (0)
+# $last_name string, имя последнего удачно залогиненого пользователя (берем из $icookie_data)
#
-# :
-# @init[icookie_data;ilogon_data;params] , / asession
-# def $logon_data.[auth.logon], ^logon[]
-# def $logon_data.[auth.logout], ^logout[]
-# $params
-# @logon[logon_data] $logon_data.[auth.name] $logon_data.[auth.passwd],
-# $logon_data.[auth.logon]
-# @logout[]
-# @insertUser[user_data] ,
-# $logon_data.[auth.name], $logon_data.[auth.email] $logon_data.[auth.passwd]
-#
-# @updateUser[user_data] ,
-# $logon_data.[auth.name], $logon_data.[auth.email] $logon_data.[auth.passwd]
+# МЕТОДЫ ОБЪЕКТА:
+# @init[icookie_data;ilogon_data;params] инициализирует сессию, обновляя/добавляя запись в таблицу asession
+# если def $logon_data.[auth.logon], то идет вызов ^logon[]
+# если def $logon_data.[auth.logout], то идет вызов ^logout[]
+# $params определяет поведение класса
+# @logon[logon_data] логин пользователя с $logon_data.[auth.name] и $logon_data.[auth.passwd],
+# если определена $logon_data.[auth.logon]
+# @logout[] отключение текущего пользователя
+# @insertUser[user_data] добавляет в базу информацию о пользователе, записывая параметры
+# $logon_data.[auth.name], $logon_data.[auth.email] и $logon_data.[auth.passwd]
+# возвращает статусы
+# @updateUser[user_data] обновляет в базе информацию о текущем пользователе, записывая параметры
+# $logon_data.[auth.name], $logon_data.[auth.email] и $logon_data.[auth.passwd]
# @makeRandomID[] make random code using ^math:md5[]
# @makeSessionID[] make random session code
-# @saveParam[sParamName;sParamValue;iExpires] ( , - )
-# @setTemporaryPasswd[email;name] (
-# ) .
-# - .
-# @setPasswdFromTemporary[email;name;code] email[/name]/code [new_passwd]
-# passwd
-# @getUser[hParams]
-# @getAllUsers[]
-# @getGroups[]
-# @getUserGroups[sUserList] ,
-# @getGroupUsers[iGroupId]
-# @getACL[object_list;user_list] ACL ()
-# @getFullACL[object_list] ACL ,
-# @getRightsToObject[object;thread;acl;is_owner]
-# @setExpireHeaders[date] Last-Modified, Expires
+# @saveParam[sParamName;sParamValue;iExpires] сохраняет значение (по умолчанию в куках, если надо иное - перекрыть)
+# @setTemporaryPasswd[email;name] вставляет в базу сгенерированный временный пароль (чтобы его активировать
+# нужно подтверждение) и возвращает его. Если пользователя с таким адресом
+# нет - возвращает пустое значение.
+# @setPasswdFromTemporary[email;name;code] проверяет комбинацию email[/name]/code [new_passwd] и в случае совпадения
+# переписывает его в passwd
+# @getUser[hParams] достает из БД информацию о пользователе по заданым параметрам
+# @getAllUsers[] достает из БД список всех пользователей
+# @getGroups[] достает из БД список групп
+# @getUserGroups[sUserList] возвращает список групп, в которых состоят пользователи
+# @getGroupUsers[iGroupId] возвращает список пользователей для заданой группы с их правами
+# @getACL[object_list;user_list] достает из БД ACL списка пользователей (групп) на объекты
+# @getFullACL[object_list] возвращает ACL пользователя и групп, в которых он состоит на объекты
+# @getRightsToObject[object;thread;acl;is_owner] вычисляет эффективные права пользователя на объект
+# @setExpireHeaders[date] ставит заданную дату в Last-Modified, иначе ставит Expires
# @xmlFormLogon[hParams] print xml for logon form
# @xmlFormLogout[hParams] print xml for logout form
# @htmlFormLogon[hParams] print html for logon form
# @htmlFormLogout[hParams] print html for logout form
# @cryptPassword[sPassword] crypt password using ^math:crypt[]
-# @isValidPassword[sPassword;sPasswordCrypted] bool
+# @isValidPassword[sPassword;sPasswordCrypted] проверяет пароль и возвращает bool
@@ -87,22 +87,22 @@ $rights_hash[^hash::create[]]
###########################################################################
# constructor
-# $icookie_data cookie ($cookie:CLASS)
-# $ilogon_data, logon/logout
-# $ilogon_data $form:fields , logon/logout
-# $params - , . ( ):
-# $.is_groups_disabled(0) -
-# $.is_delay_groups(0) -
-# $.session_lifetime(14) - asession,
-# $.cookie_sid_lifetime(0) - , , (0 - )
-# $.cookie_uid_lifetime(365) - , ,
-# $.timeout(15) - , dt_access asession,
-# $.event_lifetime(7) - aevent_log,
-# $.event_min_count(30) - ,
-# $.new_user_event_type(147) -
+# в качестве $icookie_data обычно передаются все cookie ($cookie:CLASS)
+# если определена $ilogon_data, то при инициализации идет попытка logon/logout пользователя
+# обычно в $ilogon_data стОит передавать $form:fields со странички, с которой осуществляется logon/logout
+# $params - хеш, определяющий поведение класса. возможные ключи (в скобках указаны значения по умолчанию):
+# $.is_groups_disabled(0) - не доставать группы
+# $.is_delay_groups(0) - не доставать полный список групп пока он не потребуется
+# $.session_lifetime(14) - время хранения записей в табличке asession, дней
+# $.cookie_sid_lifetime(0) - время, на которое ставится сессионная кука, дней (0 - сессионная кука)
+# $.cookie_uid_lifetime(365) - время, на которое ставится пользовательская кука, дней
+# $.timeout(15) - время, через которое мы обновляем поле dt_access в asession, минут
+# $.event_lifetime(7) - время хранения записей в табличке aevent_log, дней
+# $.event_min_count(30) - количество последних хранящихся записей событий для каждого пользователя, записей
+# $.new_user_event_type(147) - какие события у вновь создаваемых пользователей будем писать в лог
@init[icookie_data;ilogon_data;params]
-# $icookie_data - .
+# если нам не передали $icookie_data - то данные берем из кук.
$cookie_data[^if(def $icookie_data){$icookie_data}{$cookie:CLASS}]
$logon_data[^hash::create[$ilogon_data]]
@@ -111,7 +111,7 @@ $logon_data[^hash::create[$ilogon_data]]
^self.initSession[$cookie_data]
-#
+# инициализируем пользователя
^try{
^self.logon[$logon_data]
}{
@@ -127,7 +127,7 @@ $logon_data[^hash::create[$ilogon_data]]
###########################################################################
-# ,
+# НЕ ПЕРЕКРЫВАТЬ, иначе переменные не будут видны из родительского класса
@declareVars[params]
$now[^date::now[]]
$last_name[]
@@ -154,7 +154,7 @@ $user[
^self.initErrorTable[]
-# , sql
+# нам ОБЯЗАТЕЛЬНО должны передать объект, через который будут делаться все sql запросы
$oSql[^if(def $params.oSql){$params.oSql}{$params.csql}]
^if(!def $oSql){
^throw[auth;Initialization failure. ^$.oSql or ^$.csql option MUST be specified.]
@@ -165,17 +165,17 @@ $csql[$oSql]
$EVENT[^events.menu{$.[$events.name][$events.id]}]
$ERROR[^errors.menu{$.[$errors.name][$errors.id]}]
-# -
+# если нам не нужны группы - можно отключить их
$is_groups_disabled(^params.is_groups_disabled.int(0))
-# ( $is_delay_groups) -
+# если полный список групп пока не нужен (определен флаг $is_delay_groups) - не достаем их
^if($is_groups_disabled || ^params.is_delay_groups.int(0)){
$groups[^table::create{}]
}{
^self.getGroups[]
}
-# logon logon_data.[auth.persistent]
+# если идет logon то запоминаем значение пришеднее в logon_data.[auth.persistent]
^if(def $logon_data.[auth.logon]){
$is_persistent(^if(^logon_data.[auth.persistent].int(0)){1}{0})
^self.saveParam[auth.persistent;$is_persistent;365]
@@ -183,25 +183,25 @@ $is_groups_disabled(^params.is_groups_disabled.int(0))
$is_persistent(^cookie_data.[auth.persistent].int(0))
}
-# asession ()
+# время хранения записей в табличке asession (дней)
$session_lifetime(^params.session_lifetime.int(14))
-# , (, 0 - , persistent, )
+# время, на которое ставится сессионная кука (дней, 0 - сессионная, если установлен persistent, то ставим на год )
$cookie_sid_lifetime(^params.cookie_sid_lifetime.double(^if($is_persistent){365}{0}))
-# , ()
+# время, на которое ставится пользовательская кука (дней)
$cookie_uid_lifetime(^params.cookie_uid_lifetime.double(365))
-# , dt_access asession ()
+# время, через которое мы обновляем поле dt_access в таблице asession (минут)
$timeout(^params.timeout.int(15))
-# aevent_log ()
+# время жизни записей в табличке aevent_log (дней)
$event_lifetime(^params.event_lifetime.int(7))
-#
+# сколько минимально последних записей мы храним по каждому пользователю
$event_min_count(^params.event_min_count.int(30))
-# event_type, : //
+# event_type, который автоматически прописывается новым юзерам: пишем логин/логаут/изменение имени
$new_user_event_type(^params.new_user_event_type.int($EVENT.update_user + $EVENT.logon + $EVENT.logout + $EVENT.change_name))
^if($params.additional_fields is "table"){
@@ -214,25 +214,25 @@ $new_user_event_type(^params.new_user_event_type.int($EVENT.update_user + $EVENT
###########################################################################
-# ,
+# события, которые у нас бывают
@getEvents[]
$result[^table::create{id name description is_editable
1 logon Login 1
2 logout Logout 1
-4 request_password 1
-8 change_password 1
-16 change_name 1
-32 change_email email 1
-64 change_rights
-128 update_user
-256 insert_user
+4 request_password Запрос пароля 1
+8 change_password Изменение пароля 1
+16 change_name Изменение логина 1
+32 change_email Изменение email 1
+64 change_rights Изменение прав
+128 update_user Изменение пользователя
+256 insert_user Добавление пользователя
}]
#end @getEvents[]
###########################################################################
-# , 16
+# коды ошибок, думаю 16 бит должно хватить
@getErrors[]
$result[^table::create{id name
1 not_logged
@@ -250,14 +250,14 @@ $result[^table::create{id name
###########################################################################
-# $cookie_data
+# инициализация сессии на основании $cookie_data
@initSession[cookie_data][last_sessions;valid_session;sid;uid]
$valid_session[^hash::create[]]
^if(def $cookie_data.[cookie] || def $cookie_data.[auth.uid]){
^if(def $cookie_data.[auth.uid]){
- ^rem{ *** auid, . , *** }
- ^rem{ *** - , sid , *** }
- ^rem{ *** sid ( ) - . *** }
+ ^rem{ *** достаем все записи с auid, который пришел от пользователя. записей может быть несколько, *** }
+ ^rem{ *** но актуальная только одна - та, у которой наша sid или, *** }
+ ^rem{ *** если от юзера не пришла sid (новая сессия) - самая последняя. *** }
$last_sessions[^oSql.table{
SELECT
asession_id AS session_id,
@@ -308,20 +308,20 @@ $session[$valid_session]
###########################################################################
-# logon_data, ,
-# - asession_id
-# $init_type = 0 -
+# если задана logon_data, то попытка логина с задаными параметрами,
+# иначе - попытка установить связь по текущей asession_id
+# если $init_type = 0 - у нас продолжение секущей сессии
@logon[logon_data][_type;_user]
^self.initStatus(0)
$_type[auth.logon]
^try{
^if($init_type >= 0 && $init_type < 3){
- ^rem{ *** $session.user_id *** }
+ ^rem{ *** достаем информацию о текущем юзере по $session.user_id *** }
$_user[^self.getUser[
$.user_id(^session.user_id.int(0))
]]
^if($init_type == 2){
- ^rem{ *** , ... ... *** }
+ ^rem{ *** ни фига не помню, зачем я это делаю... надо разобраться... *** }
^oSql.void{
UPDATE
asession
@@ -334,13 +334,13 @@ $_type[auth.logon]
$_user[]
}{
^if(def $logon_data.[auth.logon]){
- ^rem{ *** logon - *** }
+ ^rem{ *** если при этом идет logon - то надо отлогинить текущего юзера *** }
^self.logout[]
}
}
}
^if($init_type >= 0 && def $logon_data.[auth.logon] && def $logon_data.[auth.name] && def $logon_data.[auth.passwd]){
- ^rem{ *** logon - / *** }
+ ^rem{ *** если идет logon - достаем информацию о пользователе по введенным имени/паролю *** }
$_user[^self.getUser[
$.name[$logon_data.[auth.name]]
$.password[$logon_data.[auth.passwd]]
@@ -349,7 +349,7 @@ $_type[auth.logon]
^self.addErrorCode[user_not_found]
^throw[$_type;errors]
}
- ^rem{ *** *** }
+ ^rem{ *** обновляем информацию о сессии и пользователе в базе *** }
^oSql.void{
UPDATE
asession
@@ -403,7 +403,7 @@ $last_name[$cookie_data.[auth.name]]
###########################################################################
-#
+# завершение текущей авторизированой сессии пользователя
@logout[]
^if($session){
^oSql.void{
@@ -425,7 +425,7 @@ $last_name[$cookie_data.[auth.name]]
WHERE
auser_id = $user.user_id
}
- ^rem{ *** *** }
+ ^rem{ *** пишем в лог об этом событии *** }
^self.logEvent[$user]($EVENT.logout)
}
}
@@ -483,7 +483,7 @@ $result[^table::create{code name}]
###########################################################################
-# 1 $name
+# возвращает 1 если в последней операции произошла ошибка $name
@isError[sErrorName]
$result(^if($status & $ERROR.$sErrorName){1}{0})
#end @isError[]
@@ -491,8 +491,8 @@ $result(^if($status & $ERROR.$sErrorName){1}{0})
###########################################################################
-# event_type
-# -
+# запись логов в соответствии с event_type
+# если у данного пользователя установлен бит на протоколирование текущего события - добавляем в лог запись
@logEvent[user;event_type;status;content][user_id;event;exist;keep_events;addon]
^if($user && $user.event_type & $event_type){
$event($event_type)
@@ -527,7 +527,7 @@ $result(^if($status & $ERROR.$sErrorName){1}{0})
'^self.getStationAddr[]${addon}^if(def $content){, $content}'
)}
- ^rem{ *** now() - $event_lifetime, $event_min_count *** }
+ ^rem{ *** надо удалить все сообщения старее чем now() - $event_lifetime, но оставить не меньше чем $event_min_count *** }
$keep_events[^oSql.table{
SELECT
aevent_log_id AS id
@@ -601,7 +601,7 @@ $result[]
###########################################################################
-#
+# добавление нового пользователя
@insertUser[user_data][_type]
$_type[auth.insert]
^self.initStatus(0)
@@ -649,10 +649,10 @@ $_type[auth.insert]
]
^try{
- ^rem{ *** *** }
+ ^rem{ *** загружаем полный список групп *** }
^self.getGroups[]
- ^rem{ *** , is_default *** }
+ ^rem{ *** включаем вновь добавленного пользователя в группы, у которых установлен флаг is_default *** }
^groups.menu{
^if($groups.is_default){
^oSql.void{INSERT INTO auser_to_auser (
@@ -665,7 +665,7 @@ $_type[auth.insert]
}
}
}{
- ^rem{ *** - () *** }
+ ^rem{ *** если не удалось добавить пользователя в группы - ну и хрен с ними (пока) *** }
$exception.handled(1)
}
^self.postInsert[$new_user.user_id;$user_data]
@@ -685,7 +685,7 @@ $_type[auth.insert]
###########################################################################
-#
+# метод выполняется после успешного добавления нового пользователя
@postInsert[iUserId;hUser]
#end @postInsert[]
@@ -724,7 +724,7 @@ $result[]
###########################################################################
-#
+# изменение параметров пользователя
@updateUser[user_data][_type;_event_type;_comment;_user]
$_type[auth.update]
^self.initStatus(0)
@@ -798,14 +798,14 @@ $_type[auth.update]
###########################################################################
-#
+# метод выполняется после успешного изменения параметров пользователя
@postUpdate[iUserId;hUser]
#end @postUpdate[]
###########################################################################
-# email/name
-# email/name ( ) ,
+# генерит и запоминает новый пароль для пользователя с заданым email/name
+# в случае наличия пользователя с этим email/name (причем валидным) возвращает пароль, иначе возвращает пустую строку
@setTemporaryPasswd[email;name][_type;_exist;_user]
$result[]
$_type[auth.set_temporary_password]
@@ -867,7 +867,7 @@ $_type[auth.set_temporary_password]
###########################################################################
-# $email[/$name]/$code
+# для пользователя с заданной комбинацией $email[/$name]/$code делает временный пароль в постоянным
@setPasswdFromTemporary[email;name;code][_exist;_stat;_user]
$_type[auth.set_password_from_temporary]
^self.initStatus(0)
@@ -924,7 +924,7 @@ $_type[auth.set_password_from_temporary]
###########################################################################
-# asession
+# метод апдейтит запись в таблице asession
@updateSession[uid;sid;session_id]
^oSql.void{
DELETE FROM
@@ -934,7 +934,7 @@ $_type[auth.set_password_from_temporary]
^if(def $session_id){AND asession_id != ^session_id.int(0)}
}
^if(def $session_id){
- ^rem{ *** *** }
+ ^rem{ *** апдейтим запись в базе *** }
^oSql.void{
UPDATE
asession
@@ -952,7 +952,7 @@ $_type[auth.set_password_from_temporary]
$.dt_access[^now.sql-string[]]
]
}{
- ^rem{ *** *** }
+ ^rem{ *** добавляем запись в базу *** }
^oSql.void{INSERT INTO asession (
auid,
sid,
@@ -980,9 +980,9 @@ $_type[auth.set_password_from_temporary]
###########################################################################
-#
-# auth.uid.updated , (7 ),
-# , auth.uid, auth.uid...
+# метод пишет сессионные параметры пользователю
+# смысл парметра auth.uid.updated в том, что он выдается на достаточно небольшой период (7 дней), и если вдруг он
+# уже устарел, то заново сохраняем его и auth.uid, таким образом не нужно каждый раз сохранять auth.uid...
@updateSessionParams[sid;uid;is_force_set_uid]
^if(def $is_force_set_uid || !def $cookie_data.[auth.uid.updated] || $cookie_data.[auth.uid] ne $uid){
^self.saveParam[auth.uid;$uid;$cookie_uid_lifetime]
@@ -1003,7 +1003,7 @@ $result[^math:md5[^now.sql-string[]^math:random(1000000)]]
###########################################################################
-#
+# метод возвращает информацию о компьютере посетителя
@getStationAddr[]
$result[^if(def $env:REMOTE_ADDR){$env:REMOTE_ADDR}{NULL}:^if(def $env:HTTP_X_FORWARDED_FOR){$env:HTTP_X_FORWARDED_FOR}{NULL}]
#end @getStationAddr[]
@@ -1020,8 +1020,8 @@ $result[^self.getStationAddr[]=^self.makeRandomID[]]
###########################################################################
-# asession ..
-#
+# у каждого пользователя сохраняем самую последнюю запись в asession т.к. по ней мы
+# сможет восстановить его сессию после долгого перерыва и получить дату последнего визита
@clearSession[date_diff][cleared_users;deleted_sessions;uid;cnt;ids;tmp]
# clear expired non authorized sessions
@@ -1047,7 +1047,7 @@ $cleared_users[^oSql.table{
COUNT(*) > 1
}]
^if($cleared_users){
- ^rem{ *** , *** }
+ ^rem{ *** достаем сессии, которые надо будет удалять *** }
$deleted_sessions[^oSql.table{
SELECT
asession_id AS id,
@@ -1248,8 +1248,8 @@ $result[]
###########################################################################
-# root
-# $sUserList
+# достает ид БД список групп в которых состоят пользователи с их правами на root
+# если не задали $sUserList то возвращаем данные о принадлежности к группам для текущего пользователя
@getUserGroups[sUserList]
$result[^oSql.table{
SELECT
@@ -1300,7 +1300,7 @@ $result[^oSql.table{
###########################################################################
-# Access Control List (ACL) (, )
+# достает из БД Access Control List (ACL) списка пользователей (групп, овнера) на объекты
@getACL[sObjectList;sUserList]
$result[^oSql.table{
SELECT
@@ -1331,13 +1331,13 @@ $result[^oSql.table{
###########################################################################
-# ACL ,
+# возвращает информацию о ACL пользователя и групп, в которых он состоит на объекты
@getFullACL[object_list][obj_list;acl]
$obj_list[^if($object_list is "table" && $object_list){^object_list.menu{$object_list.id}[,]}{$object_list}]
^self.loadUserGroups[]
-^rem{ *** owner auser_id = 1 *** }
+^rem{ *** у объекта owner auser_id = 1 *** }
$acl[^self.getACL[$obj_list;1,^user.groups.menu{$user.groups.group_id,}$user.user_id]]
$result[
$.user[^acl.select($acl.auser_type_id == $USER_ID)]
@@ -1360,57 +1360,57 @@ $result[]
###########################################################################
-# ,
-# ,
-# $object [table/hash] ($object.id, $object.parent_id, $object.irf)
-# $thread [table] ( - , )
-# $acl [hash] , , , ,
+# Вычисляет эффективные права текущего пользователя на объект, рекурсивно вызывая себя при необходимости
+# Полученые права сохраняет в хеше, чтобы повторно не считать их
+# в $object [table/hash] должен быть сам объект ($object.id, $object.parent_id, $object.irf)
+# в $thread [table] должны быть все его родители (с такими-же полями, как минимум)
+# в $acl [hash] должны быть права юзера, овнера, групп, в которых он состоит, на все объекты треда
@getRightsToObject[object;thread;acl;is_owner][parent_rights;level_user_acl;level_group_acl;level_owner_acl;level_rights]
^if($object){
^if($rights_hash.[$object.id]){
- ^rem{ *** - *** }
+ ^rem{ *** если права есть в хеше - забираем их *** }
$result($rights_hash.[$object.id])
}{
^if($thread){
^if(^object.irf.int(0)){
- ^rem{ *** irf 0 - , *** }
- ^rem{ *** locate - root *** }
+ ^rem{ *** если у объекта irf не равен 0 - вычисляем права на родителя, вызывая себя рекурсивно *** }
+ ^rem{ *** если locate не находит очередного родителя - значит достаем права данные на root *** }
$parent_rights(^self.getRightsToObject[^if(^thread.locate[id;$object.parent_id]){$thread.fields};$thread;$acl;$is_owner])
}{
- ^rem{ *** irf 0 ( ) - *** }
+ ^rem{ *** irf равен 0 (все замаскировано) - права можно не считать *** }
$parent_rights(0)
}
- ^rem{ *** , (+ ) *** }
+ ^rem{ *** вычисляем права, данные на текущий объект пользователю (+ как овнеру) и группам в которых он состоит *** }
$level_rights(0)
$level_user_acl[^acl.user.select($acl.user.object_id == $object.id)]
^if($level_user_acl){
- ^rem{ *** , *** }
+ ^rem{ *** если есть право данное непосредственно пользователю, то это право перекрывает право данное через группы *** }
$level_rights($level_rights | $level_user_acl.rights)
}{
- ^rem{ *** , *** }
+ ^rem{ *** добавляем права, данные ему через членство в группах *** }
$level_group_acl[^acl.group.select($acl.group.object_id == $object.id)]
^level_group_acl.menu{$level_rights($level_rights | $level_group_acl.rights)}
}
- ^rem{ *** owner-, $is_owner *** }
+ ^rem{ *** добавляем его права как owner-а, если установлен флаг $is_owner *** }
^if($is_owner){
$level_owner_acl[^acl.owner.select($acl.owner.object_id == $object.id)]
^level_owner_acl.menu{$level_rights($level_rights | $level_owner_acl.rights)}
}
- ^rem{ *** , ( irf ) *** }
+ ^rem{ *** к правам пришедших от родителя добавляем права, данные на этот объект (с учетом irf объекта) *** }
$result(($parent_rights & ^object.irf.int(0)) | $level_rights)
- ^rem{ *** , , *** }
+ ^rem{ *** кладем посчитаное значение в хеш, чтобы не считать еще раз, если понадобится *** }
^self.addRightsToHash[rights_hash;$object.id;$result]
}{
- ^rem{ *** , . ... *** }
+ ^rem{ *** не передали информацию о треде, а он нам нужен. посчитать ничего не можем... *** }
^throw[auth;Thread with objects MUST be defined.]
}
}
}{
- ^rem{ *** object, root - *** }
+ ^rem{ *** не задан object, значит просят права на root - отдаем их *** }
^if($rights_hash.[0]){
- ^rem{ *** - *** }
+ ^rem{ *** если права есть в хеше - забираем их *** }
$result($rights_hash.[0])
}{
^if($user.rights){
@@ -1500,10 +1500,10 @@ $hParam[^hash::create[$hParam]]
>
$hParam.addon
-
-
-
-
+
+
+
+
^if(def $hParam.tag_name){$hParam.tag_name}{auth-logon}>
}
#end @xmlFormLogon[]
@@ -1525,7 +1525,7 @@ $hParam[^hash::create[$hParam]]
$hParam.addon
$user.name
-
+
^if(def $hParam.tag_name){$hParam.tag_name}{auth-logout}>
}
}
@@ -1549,10 +1549,10 @@ $_hParams[^hash::create[$hParams]]
-
-
+
+
-
+
$_hParams.post_addon
}
^if(def $_hParams.tag_name){$_hParams.tag_name}{form}>
@@ -1572,12 +1572,12 @@ $hParam[^hash::create[$hParam]]
}
>
- :
+ Логин: