public function registerCacheManager()
{
$this->app->bind(CacheManager::class, function ($app) {
$manager = new CacheManager($app['config']['doctrine::doctrine.cache']);
$manager->add(new ApcProvider());
$manager->add(new MemcacheProvider());
$manager->add(new RedisProvider());
$manager->add(new XcacheProvider());
$manager->add(new ArrayProvider());
return $manager;
});
}
function Styles_XML($Element)
{
/****************************************************************************/
$__args_types = array('string');
#-----------------------------------------------------------------------------
$__args__ = Func_Get_Args();
eval(FUNCTION_INIT);
/****************************************************************************/
$CacheID = SPrintF('Styles_XML[%s]', Md5($Element));
#-----------------------------------------------------------------------------
$Result = CacheManager::get($CacheID);
if ($Result) {
return $Result;
}
#-----------------------------------------------------------------------------
$HostsIDs = Styles_HostsIDs($Element);
if (Is_Error($HostsIDs)) {
return ERROR | @Trigger_Error('[Styles_XML]: список хостов содержащих элемент не найдены');
}
#-----------------------------------------------------------------------------
$Result = array();
#-----------------------------------------------------------------------------
foreach (Array_Reverse($HostsIDs) as $HostID) {
#---------------------------------------------------------------------------
$Path = SPrintF('%s/styles/%s/%s', SYSTEM_PATH, $HostID, $Element);
#---------------------------------------------------------------------------
$File = IO_Read($Path);
if (Is_Error($File)) {
return ERROR | @Trigger_Error('[Styles_XML]: не удалось прочитать XML-файл');
}
#---------------------------------------------------------------------------
$XML = String_XML_Parse($File);
if (Is_Exception($XML)) {
return ERROR | @Trigger_Error('[Styles_XML]: не удалось разобрать XML-строку');
}
#---------------------------------------------------------------------------
$Child = Current($XML->Childs);
#---------------------------------------------------------------------------
if (isset($Child->Attribs['recursive'])) {
$Result = array();
}
#---------------------------------------------------------------------------
$Adding = $XML->ToArray();
#---------------------------------------------------------------------------
$Adding = $Adding['XML'];
#---------------------------------------------------------------------------
Array_Union($Result, $Adding);
}
#-----------------------------------------------------------------------------
CacheManager::add($CacheID, $Result);
#-----------------------------------------------------------------------------
return $Result;
}
if (Is_Error($IsUpdate)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
unset($IsOK);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# добавляем в кэш обработанный сервер
if (!isset($Cache[$Group])) {
$Cache[$Group] = array();
}
#-------------------------------------------------------------------------------
$Cache[$Group][] = $Server['Address'];
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# помечаем группу как обработанную
if (isset($Group)) {
$Cache[$Group]['IsComplete'] = TRUE;
}
#-------------------------------------------------------------------------------
# Сохраняем кэшированные данные
CacheManager::add($CacheID, $Cache, 300);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# если в процессе работы была задана группа - то возможно она не последняя, короткий цикл, если не задана - то все сервера обработаны - длинный
return isset($Group) ? Time() + 10 : $ExecuteTime;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Order = DB_Select(SPrintF('%sOrdersOwners', $ServiceCode), 'OrderID', array('UNIQ', 'ID' => $ServiceOrderID));
#-------------------------------------------------------------------------------
switch (ValueOf($Order)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
#-------------------------------------------------------------------------------
if ($IsNotFound) {
return "00000";
}
#-------------------------------------------------------------------------------
return ERROR | @Trigger_Error(400);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
case 'array':
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Order['OrderID'], 24 * 3600);
#-------------------------------------------------------------------------------
return $Order['OrderID'];
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Emblem = Styles_Element(SPrintF('Images/Icons/%s.png', $Service['Code']));
if (Is_Error($Emblem)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
$Emblem = IO_Read($Emblem);
if (Is_Error($Emblem)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$File = GetUploadedFile('Services', $ServiceID);
#-------------------------------------------------------------------------------
$Emblem = $File['Data'];
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Emblem, 24 * 3600);
#-------------------------------------------------------------------------------
Header('Content-Type: image');
Header('Cache-Control: private, max-age=86400');
#-------------------------------------------------------------------------------
return $Emblem;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$IsUpdate = DB_Update('DomainOrders', array('UpdateDate' => Time()), array('ID' => $DomainOrder['ID']));
if (Is_Error($IsUpdate)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
$Event = array('UserID' => $DomainOrder['UserID'], 'PriorityID' => 'Warning', 'Text' => SPrintF('Повторная ошибка получения данных WhoIs для домена %s.%s, проверка пропущена', $DomainOrder['DomainName'], $DomainOrder['SchemeName']));
#-------------------------------------------------------------------------------
$Event = Comp_Load('Events/EventInsert', $Event);
if (!$Event) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, 1, 3600);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
return new gException('WHOIS_SERVER_ERROR', 'Ошибка сервера WhoIs');
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
case 'exception':
return new gException('CAN_NOT_GET_WHOIS_DATA', 'Не удалось получить данные WhoIs', $WhoIs);
case 'false':
return new gException('DOMAIN_ZONE_NOT_SUPPORTED', 'Доменная зона не поддерживается');
case 'array':
#-------------------------------------------------------------------------------
$UDomainOrder = array('UpdateDate' => Time(), 'WhoIs' => $WhoIs['Info']);
#-------------------------------------------------------------------------------
$ExpirationDate = $WhoIs['ExpirationDate'];
function String_Xml_Parse($String, $IsUseCache = TRUE)
{
#-------------------------------------------------------------------------------
# костыль для удаления не-UTF8 символов
$String = iconv('UTF-8', 'UTF-8//IGNORE', $String);
#-------------------------------------------------------------------------------
$Length = Mb_StrLen($String);
#-------------------------------------------------------------------------------
$IsUseCache = $IsUseCache && $Length > 1024;
#-------------------------------------------------------------------------------
if ($IsUseCache) {
#-------------------------------------------------------------------------------
$CacheID = SPrintF('String_XML_Parse[%s]', Md5(Crc32($String)));
#-------------------------------------------------------------------------------
$Result = CacheManager::get($CacheID);
if ($Result) {
return $Result;
}
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
Debug(SPrintF('[String_XML_Parse]: парсирование строки (%u bytes)', $Length));
#-------------------------------------------------------------------------------
$XmlParser = Xml_Parser_Create('UTF-8');
#-------------------------------------------------------------------------------
if (!Xml_Parser_Set_Option($XmlParser, XML_OPTION_CASE_FOLDING, FALSE)) {
return ERROR | Trigger_Error('[String_Xml_Parse]: не удалось установить опцию парсирования (XML_OPTION_CASE_FOLDING)');
}
#-------------------------------------------------------------------------------
if (!Xml_Parser_Set_Option($XmlParser, XML_OPTION_SKIP_WHITE, FALSE)) {
return ERROR | Trigger_Error('[String_Xml_Parse]: не удалось установить опцию парсирования (XML_OPTION_SKIP_WHITE)');
}
#-------------------------------------------------------------------------------
if (!Xml_Parse_Into_Struct($XmlParser, $String, $Nodes)) {
#-------------------------------------------------------------------------------
$ByteIndex = Xml_Get_Current_Byte_Index($XmlParser);
#-------------------------------------------------------------------------------
Debug(SPrintF('[system/libs/auto/String.php]: xml_error_string = %s', Xml_Error_String(Xml_Get_Error_Code($XmlParser))));
#-------------------------------------------------------------------------------
Debug(SPrintF('[system/libs/auto/String.php]: %s', Mb_SubStr($String, $ByteIndex - 100, $ByteIndex + 100)));
#-------------------------------------------------------------------------------
$Buffer = Mb_SubStr($String, 0, $ByteIndex);
#-------------------------------------------------------------------------------
$Line = Preg_Match_All("/(\r\n|\n)/sU", $Buffer, $Matches) + 1;
#-------------------------------------------------------------------------------
return new gException('XML_PARSE_ERROR', SPrintF('%s в линии %u', Xml_Error_String($XmlParser), $Line));
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-----------------------------------------------------------------------------
Xml_Parser_Free($XmlParser);
#-----------------------------------------------------------------------------
$Root = new Tag('__ROOT__');
#-----------------------------------------------------------------------------
$Links = array(&$Root);
#-----------------------------------------------------------------------------
foreach ($Nodes as $Node) {
#---------------------------------------------------------------------------
$Current = $Links[Count($Links) - 1];
#---------------------------------------------------------------------------
switch ($Node['type']) {
case 'open':
#-----------------------------------------------------------------------
$Tag = new Tag($Node['tag']);
#-----------------------------------------------------------------------
if (isset($Node['attributes'])) {
$Tag->AddAttribs($Node['attributes']);
}
#-----------------------------------------------------------------------
if (isset($Node['value'])) {
#---------------------------------------------------------------------
$Value = $Node['value'];
#---------------------------------------------------------------------
if (Trim($Value)) {
$Tag->AddChild(new Tag('CDATA', $Value));
}
}
#-----------------------------------------------------------------------
$Current->Childs[] = $Tag;
#-----------------------------------------------------------------------
$Links[] =& $Current->Childs[Count($Current->Childs) - 1];
break;
case 'cdata':
#-----------------------------------------------------------------------
$Value = $Node['value'];
#-----------------------------------------------------------------------
if (Trim($Value)) {
#---------------------------------------------------------------------
$Tag = new Tag('CDATA', $Value);
#---------------------------------------------------------------------
$Current->Childs[] = $Tag;
}
break;
case 'complete':
#-----------------------------------------------------------------------
$Tag = new Tag($Node['tag']);
#-----------------------------------------------------------------------
if (isset($Node['attributes'])) {
$Tag->AddAttribs($Node['attributes']);
}
#-----------------------------------------------------------------------
if (isset($Node['value'])) {
$Tag->AddText($Node['value']);
}
#-----------------------------------------------------------------------
$Current->Childs[] = $Tag;
break;
case 'close':
Array_Pop($Links);
break;
default:
# No more...
}
}
#-----------------------------------------------------------------------------
if ($IsUseCache) {
CacheManager::add($CacheID, $Root);
}
#-----------------------------------------------------------------------------
return $Root;
}
}
#-------------------------------------------------------------------------------
$NoBody = new Tag('NOBODY');
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Where = array("`StatusID` = 'Working' OR `StatusID` = 'Newest'", "`Flags` != 'CloseOnSee'", "(SELECT `IsDepartment` FROM `Groups` WHERE `Groups`.`ID` = `Edesks`.`TargetGroupID`) = 'yes'", "(SELECT `IsDepartment` FROM `Groups` WHERE `Groups`.`ID` = (SELECT `GroupID` FROM `Users` WHERE `Users`.`ID` = `Edesks`.`UserID`)) = 'no'");
#-------------------------------------------------------------------------------
$Count = DB_Count('Edesks', array('Where' => $Where));
if (Is_Error($Count)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
if ($Count) {
$NoBody->AddChild(new Tag('A', array('href' => '/Administrator/Tickets', 'class' => 'Image'), new Tag('IMG', array('alt' => 'Новые сообщения', 'border' => 0, 'width' => 13, 'height' => 9, 'src' => 'SRC:{Images/Icons/Message1.gif}'))));
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (Count($NoBody->Childs)) {
#-------------------------------------------------------------------------------
$NoBody->AddChild(new Tag('SPAN', $Adding));
#-------------------------------------------------------------------------------
$Adding = $NoBody;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Adding, 60);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return $Adding;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (!isset($_SERVER["HTTP_REFERER"])) {
#-------------------------------------------------------------------------------
$Count = IntVal(CacheManager::get($CacheID));
#-------------------------------------------------------------------------------
if ($Count > 2) {
#-------------------------------------------------------------------------------
$NoBody = new Tag('NOBODY');
#-------------------------------------------------------------------------------
$NoBody->AddHTML(TemplateReplace('Notes.User.CheckReferer'));
#-------------------------------------------------------------------------------
$Result[] = $NoBody;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$Count++;
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Count, 600);
#-------------------------------------------------------------------------------
Debug(SPrintF('[comp/Notes/User/CheckReferer]: HTTP_REFERER is not set for IP = %s, Count = %u', $_SERVER['REMOTE_ADDR'], $Count));
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, 0, 600);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return $Result;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
break;
default:
return ERROR | @Trigger_Error(101);
}
#-----------------------------------------------------------------------------
for ($i = 0; $i < Count($Services); $i++) {
$Query = DB_Query(SPrintF("SHOW TABLES LIKE '%s%%OrdersOwners'", $Services[$i]['Code']));
$Row = MySQL::Result($Query);
foreach (Array_Keys($Row[0]) as $Key) {
$Services[$i]['View'] = $Row[0][$Key];
}
$View = Preg_Split('/Owner/', $Services[$i]['View']);
$Services[$i]['Table'] = Current($View);
}
#-----------------------------------------------------------------------------
CacheManager::add($CacheID, $Services, 600);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#Debug("[Tasks/GC/EraseDeletedOrders]: " . print_r($Services,true));
#-------------------------------------------------------------------------------
for ($i = 0; $i < Count($Services); $i++) {
Debug(SPrintF("[Tasks/GC/EraseDeletedOrders]: Код текущей услуги - %s", $Services[$i]['Code']));
#-----------------------------------------------------------------------------
$Where = SPrintF("`StatusID` = 'Deleted' AND `StatusDate` < UNIX_TIMESTAMP( ) - %d *86400", $Params['Invoices']['DaysBeforeErase']);
#-----------------------------------------------------------------------------
$Orders = DB_Select($Services[$i]['View'], array('ID', 'OrderID', 'UserID'), array('Where' => $Where));
#-----------------------------------------------------------------------------
switch (ValueOf($Orders)) {
case 'error':
return ERROR | @Trigger_Error(500);
function WhoIs_Check($DomainName, $ZoneName, $IsAvalible = FALSE)
{
#-------------------------------------------------------------------------------
Debug(SPrintF('[system/libs/WhoIs]: run function WhoIs_Check, Domain = %s.%s', $DomainName, $ZoneName));
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$CacheID = SPrintF('WhoIs-%s.%s', $DomainName, $ZoneName);
#-------------------------------------------------------------------------------
$Answer = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
if (!$Answer) {
#-------------------------------------------------------------------------------
# смотрим доменную зону, на предмет того использовать ли данные whois сервера, или юзать запросы к регистратору
$DomainZones = System_XML('config/DomainZones.xml');
if (Is_Error($DomainZones)) {
return ERROR | @Trigger_Error('[comp/www/API/WhoIs]: не удалось загрузить базу WhoIs серверов');
}
#-------------------------------------------------------------------------------
$IsSuppoted = FALSE;
#-------------------------------------------------------------------------------
foreach ($DomainZones as $Zone) {
#-------------------------------------------------------------------------------
if ($Zone['Name'] == $ZoneName) {
#-------------------------------------------------------------------------------
$IsSuppoted = TRUE;
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
if (!$IsSuppoted || $Zone['IsUseRegistratorWhoIs']) {
#-------------------------------------------------------------------------------
if (!$IsSuppoted) {
Debug(SPrintF('[comp/www/API/WhoIs]: доменная зона не поддерживается'));
}
#-------------------------------------------------------------------------------
if ($IsSuppoted && $Zone['IsUseRegistratorWhoIs']) {
Debug(SPrintF('[comp/www/API/WhoIs]: принудительное использование WhoIs регистратора'));
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# чекаем доменную зону
$Regulars = Regulars();
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars['DomainZone'], $ZoneName)) {
return ERROR | @Trigger_Error(SPrintF('[comp/www/API/WhoIs]: неверная доменная зона (%s)', $ZoneName));
}
#-------------------------------------------------------------------------------
# достаём список серверов на которых есть такой тариф
$Servers = DB_Select('DomainSchemes', array('ServerID'), array('Where' => SPrintF('`Name` = "%s"', $ZoneName)));
#-------------------------------------------------------------------------------
switch (ValueOf($Servers)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return new gException('REGISTRATOR_SERVER_NOT_FOUND', 'Не найдены активные сервера регистраторов');
case 'array':
#-------------------------------------------------------------------------------
$Array = array();
#-------------------------------------------------------------------------------
foreach ($Servers as $Server) {
$Array[] = $Server['ServerID'];
}
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
# достаём список активных серверов регистраторов
$Servers = DB_Select('Servers', array('ID', 'Address', 'Params'), array('Where' => array(SPrintF('`ID` IN (%s)', Implode(',', $Array)), '`IsActive` = "yes"'), 'SortOn' => 'Address'));
#-------------------------------------------------------------------------------
switch (ValueOf($Servers)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return new gException('REGISTRATOR_SERVER_NOT_FOUND', 'Не найдены активные сервера регистраторов');
case 'array':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
# перебираем регистраторов
$UseServer = FALSE;
#-------------------------------------------------------------------------------
foreach ($Servers as $iServer) {
#-------------------------------------------------------------------------------
# если это не проверка доступности и в настройках сервера не стоит галка про получение WhoIs - пропускаем
if (!$IsAvalible) {
if (!$iServer['Params']['IsFetchWhoIs']) {
continue;
}
}
#-------------------------------------------------------------------------------
# достаём использованные запросы к регистратору, на данную минуту
$RatelimitID = SPrintF('ratelimit-%s-%s-00', $iServer['Address'], Date('H-i'));
#-------------------------------------------------------------------------------
$Ratelimit = CacheManager::get($RatelimitID);
#-------------------------------------------------------------------------------
# если из кэша что-то досталось и оно больше разрешённой частоты запросов - пропускаем цикл
if ($Ratelimit && $Ratelimit >= $iServer['Params']['RatelimitAPI']) {
#-------------------------------------------------------------------------------
Debug(SPrintF('[comp/www/API/WhoIs]: превышена частота запросов к серверу %s (разрешено %u, использовано %u)', $iServer['Address'], $iServer['Params']['RatelimitAPI'], $Ratelimit));
#-------------------------------------------------------------------------------
continue;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
# сохраняем, на пару минут, в кэш новое число запросов к регистратору
CacheManager::add($RatelimitID, IntVal($Ratelimit) + 1, 120);
#-------------------------------------------------------------------------------
$UseServer = $iServer;
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
# если не задан сервер - частота превышена для всех серверов
if (!$UseServer) {
return new gException('REGISTRATOR_SERVER_RATELIMIT', 'Превышена максимальная частота запросов к интерфейсу регистратора');
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# выбираем сервер регистратора
if (Is_Error(System_Load('classes/DomainServer.class.php'))) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
$Server = new DomainServer();
#-------------------------------------------------------------------------------
$IsSelected = $Server->Select((int) $UseServer['ID']);
#-------------------------------------------------------------------------------
switch (ValueOf($IsSelected)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return new gException('CANNOT_SELECT_REGISTRATOR', 'Не удалось выбрать регистратора');
case 'true':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
# делаем запрос к API - функция в зависимости от $IsAvalible
if ($IsAvalible) {
#-------------------------------------------------------------------------------
$DomainCheck = $Server->DomainCheck($DomainName, $ZoneName);
#-------------------------------------------------------------------------------
switch (ValueOf($DomainCheck)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return ERROR | @Trigger_Error(400);
case 'true':
return TRUE;
case 'false':
return array();
case 'array':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$DomainWhoIs = $Server->DomainWhoIs($DomainName, $ZoneName);
#-------------------------------------------------------------------------------
switch (ValueOf($DomainWhoIs)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
# a функции нет ... вылезаем на обычную проверку whois
break;
case 'true':
return TRUE;
case 'string':
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $DomainWhoIs, 1800);
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Config = Config();
#-------------------------------------------------------------------------------
$UseSystemApplication = $Config['Other']['Libs']['WhoIs']['UseSystemApplication'];
#-------------------------------------------------------------------------------
$Regulars = Regulars();
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars['DomainName'], $DomainName)) {
return new gException('WRONG_DOMAIN_NAME', 'Неверное доменное имя');
}
#-------------------------------------------------------------------------------
$DomainZones = System_XML('config/DomainZones.xml');
if (Is_Error($DomainZones)) {
return ERROR | @Trigger_Error('[WhoIs_Check]: не удалось загрузить базу WhoIs серверов');
}
#-------------------------------------------------------------------------------
$IsSuppoted = FALSE;
#-------------------------------------------------------------------------------
foreach ($DomainZones as $DomainZone) {
#-------------------------------------------------------------------------------
if ($DomainZone['Name'] == $ZoneName) {
#-------------------------------------------------------------------------------
$IsSuppoted = TRUE;
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
if (!$IsSuppoted && !isset($DomainWhoIs)) {
return FALSE;
}
#-------------------------------------------------------------------------------
if (Mb_StrLen($DomainName) < ($MinChars = $DomainZone['MinChars'])) {
return new gException('WRONG_DOMAIN_NAME_LENGTH', SPrintF('Длина доменного имени должна быть не менее %u символа(ов)', $MinChars));
}
#-------------------------------------------------------------------------------
$Domain = SPrintF('%s.%s', $DomainName, $DomainZone['Name']);
#-------------------------------------------------------------------------------
$Answer = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
if (!$Answer) {
#-------------------------------------------------------------------------------
$IDNAConverter = new IDNAConvert();
#-------------------------------------------------------------------------------
if ($UseSystemApplication) {
#-------------------------------------------------------------------------------
$IsExec = Exec(SPrintF('whois %s', $IDNAConverter->encode($Domain)), $Answer);
#-------------------------------------------------------------------------------
$Answer = Implode("\n", $Answer);
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$Socket = @FsockOpen($DomainZone['Server'], 43, $nError, $sError, 5);
#-------------------------------------------------------------------------------
if (!$Socket) {
return ERROR | @Trigger_Error('[WhoIs_Check]: ошибка соединения с сервером WhoIs');
}
#-------------------------------------------------------------------------------
if (!@Fputs($Socket, SPrintF("%s\r\n", $IDNAConverter->encode($Domain)))) {
return ERROR | @Trigger_Error('[WhoIs_Check]: ошибка работы с серверов WhoIs');
}
#-------------------------------------------------------------------------------
$Answer = '';
#-------------------------------------------------------------------------------
do {
#-------------------------------------------------------------------------------
$Line = @Fgets($Socket, 10);
#-------------------------------------------------------------------------------
$Answer .= $Line;
#-------------------------------------------------------------------------------
} while ($Line);
#-------------------------------------------------------------------------------
Fclose($Socket);
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Answer, 1800);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
Debug(SPrintF('[system/libs/WhoIs.php]: Answer = %s', print_r($Answer, true)));
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $DomainZone['Available']), $Answer)) {
return TRUE;
}
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $DomainZone['NotAvailable']), $Answer)) {
return new gException('DOMAIN_NOT_AVAILABLE', 'Доменное имя не доступно для регистрации');
}
#-------------------------------------------------------------------------------
$Result = array('Info' => Preg_Replace('/\\n\\s+\\n/sU', "\n", Preg_Replace('/\\%.+\\n/sU', '', $Answer)), 'ExpirationDate' => 0);
#-------------------------------------------------------------------------------
$ExpirationDate = $DomainZone['ExpirationDate'];
#-------------------------------------------------------------------------------
if ($ExpirationDate) {
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $ExpirationDate), $Answer, $Mathes)) {
#-------------------------------------------------------------------------------
if (Count($Mathes) < 2) {
return ERROR | @Trigger_Error('[WhoIs_Check]: шаблон поиска даты окончания задан неверно');
}
#-------------------------------------------------------------------------------
$ExpirationDate = $Mathes[1];
#-------------------------------------------------------------------------------
$Months = array('jan', 'feb', 'mar', 'apr', 'may', 'jun', 'jul', 'aug', 'sep', 'oct', 'nov', 'dec');
#-------------------------------------------------------------------------------
if (Preg_Match('/^[0-9]{4}\\.[0-9]{2}\\.[0-9]{2}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Year', 'Month', 'Day'), Explode('.', $ExpirationDate));
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Date['Month'], $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} elseif (Preg_Match('/^[0-9]{4}\\-[0-9]{2}\\-[0-9]{2}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Year', 'Month', 'Day'), Explode('-', $ExpirationDate));
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Date['Month'], $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} elseif (Preg_Match('/^[0-9]{2}\\-[a-zA-Z]{3}\\-[0-9]{4}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Day', 'Month', 'Year'), Explode('-', $ExpirationDate));
#-------------------------------------------------------------------------------
$Month = Array_Search(StrToLower($Date['Month']), $Months);
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Month + 1, $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} elseif (Preg_Match('/^[0-9]{2}\\s[a-zA-Z]{2,10}\\s[0-9]{4}$/', $ExpirationDate)) {
#-------------------------------------------------------------------------------
$Months = array('january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'octember', 'november', 'decemeber');
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Day', 'Month', 'Year'), Preg_Split('/\\s+/', $ExpirationDate));
#-------------------------------------------------------------------------------
$Month = Array_Search(StrToLower($Date['Month']), $Months);
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Month + 1, $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$Date = Array_Combine(array('Week', 'Month', 'Day', 'Time', 'GMT', 'Year'), Preg_Split('/\\s+/', $ExpirationDate));
#-------------------------------------------------------------------------------
$Month = Array_Search(StrToLower($Date['Month']), $Months);
#-------------------------------------------------------------------------------
$ExpirationDate = MkTime(0, 0, 0, $Month + 1, $Date['Day'], $Date['Year']);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$Result['ExpirationDate'] = $ExpirationDate;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$NsName = $DomainZone['NsName'];
#-------------------------------------------------------------------------------
if ($NsName) {
#-------------------------------------------------------------------------------
if (Preg_Match_All(SPrintF('/%s/', $NsName), $Answer, $Mathes)) {
#-------------------------------------------------------------------------------
if (Count($Mathes) < 2) {
return ERROR | @Trigger_Error('[WhoIs_Check]: шаблон поиска именных серверов задан неверно');
}
#-------------------------------------------------------------------------------
$NsNames = $Mathes[1];
#-------------------------------------------------------------------------------
for ($i = 0; $i < Count($NsNames); $i++) {
#-------------------------------------------------------------------------------
$NsName = Trim(StrToLower($NsNames[$i]), '.');
#-------------------------------------------------------------------------------
$Result[SPrintF('Ns%uName', $i + 1)] = $NsName;
#-------------------------------------------------------------------------------
if ($NsName) {
#-------------------------------------------------------------------------------
if (Mb_SubStr($NsName, -Mb_StrLen($Domain)) == $Domain) {
#-------------------------------------------------------------------------------
$IP = GetHostByName($NsName);
#-------------------------------------------------------------------------------
if ($IP != $NsName) {
$Result[SPrintF('Ns%uIP', $i + 1)] = $IP;
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$Registrar = $DomainZone['Registrar'];
#-------------------------------------------------------------------------------
if ($Registrar) {
#-------------------------------------------------------------------------------
if (Preg_Match(SPrintF('/%s/', $Registrar), $Answer, $Mathes)) {
#-------------------------------------------------------------------------------
if (Count($Mathes) < 2) {
return ERROR | @Trigger_Error('[WhoIs_Check]: шаблон поиска регистратора серверов задан неверно');
}
#-------------------------------------------------------------------------------
$Registrar = Next($Mathes);
#-------------------------------------------------------------------------------
$Result['Registrar'] = $Registrar;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
return $Result;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$Params = $__USER['Params'];
#-------------------------------------------------------------------------------
$Params['NotificationMethods'][$Method]['Confirmed'] = 0;
#-------------------------------------------------------------------------------
$IsUpdate = DB_Update('Users', array('Params' => $Params), array('ID' => $__USER['ID']));
if (Is_Error($IsUpdate)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
CacheManager::add($Cache['Confirm1'], $Confirm1, 10 * 24 * 3600);
#-------------------------------------------------------------------------------
CacheManager::add($Cache['Confirm2'], $Confirm2, 10 * 24 * 3600);
#-------------------------------------------------------------------------------
CacheManager::add($Cache['Limit'], Time(), IntVal($Settings['ConfirmInterval']));
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return array('Status' => 'Ok');
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
if (empty($Confirm) && empty($Code)) {
return new gException('ERROR_CODE_EMPTY', 'Введите полученный код подтверждения, или пройдите по ссылке из сообщения');
}
#-------------------------------------------------------------------------------
$Confirm1 = CacheManager::get($Cache['Confirm1']);
#-------------------------------------------------------------------------------
$Confirm2 = CacheManager::get($Cache['Confirm2']);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
foreach (Array_Keys($ContactDetail['FullInfo']) as $Key) {
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Form/Input', array('name' => $Key, 'type' => 'hidden', 'value' => $ContactDetail['FullInfo'][$Key]));
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
$Form->AddChild($Comp);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$DOM->AddChild('Head', new Tag('SCRIPT', array('type' => 'text/javascript'), SPrintF("var \$Domain = '%s';", $Domain)));
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$DOM->AddChild('Into', $Form);
#-------------------------------------------------------------------------------
if (Is_Error($DOM->Build(FALSE))) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (isset($CacheID)) {
CacheManager::add($CacheID, Time(), 60);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return array('Status' => 'Ok', 'DOM' => $DOM->Object);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Tables/Standard', $Table);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$DOM->AddChild('Into', $Comp);
#-------------------------------------------------------------------------------
if (Is_Error($DOM->Build(FALSE))) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (isset($CacheID)) {
#-------------------------------------------------------------------------------
$Result = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
$Count = $Result ? $Result + 1 : 1;
#-------------------------------------------------------------------------------
Debug(SPrintF('[comp/www/DomainOrderRegistratorInfo]: Count = %s', $Count));
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Count, 300);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return array('Status' => 'Ok', 'DOM' => $DOM->Object);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
function Tree_Entrance($TableID, $RowID)
{
/****************************************************************************/
$__args_types = array('string', 'integer');
#-----------------------------------------------------------------------------
$__args__ = Func_Get_Args();
eval(FUNCTION_INIT);
/****************************************************************************/
$Regulars = Regulars();
#-----------------------------------------------------------------------------
if (!Preg_Match($Regulars['ID'], $TableID)) {
return new gException('WRONG_TABLE_ID', 'Неверный идентификатор таблицы');
}
#-----------------------------------------------------------------------------
$CacheID = SPrintF('Tree_Entrance[%s]', Md5(SPrintF('%s:%u', $TableID, $RowID)));
#-----------------------------------------------------------------------------
$Result = CacheManager::get($CacheID);
if (!$Result) {
#---------------------------------------------------------------------------
$Row = DB_Select($TableID, '*', array('UNIQ', 'ID' => $RowID));
#---------------------------------------------------------------------------
switch (ValueOf($Row)) {
case 'error':
return ERROR | @Trigger_Error('[Tree_Entrance]: не возможно найти запись');
case 'exception':
return new gException('ROW_NOT_FOUND', 'Запись не найдена');
case 'array':
#-----------------------------------------------------------------------
$Result = array($Row['ID']);
#-----------------------------------------------------------------------
$Where = SPrintF('`ParentID` = %u AND `ID` != `ParentID`', $Row['ID']);
#-----------------------------------------------------------------------
$Childs = DB_Select($TableID, '*', array('Where' => $Where));
#-----------------------------------------------------------------------
switch (ValueOf($Childs)) {
case 'error':
return ERROR | @Trigger_Error('[Tree_Entrance]: не возможно найти дочерние записи');
case 'exception':
#----->
break;
case 'array':
#-------------------------------------------------------------------
foreach ($Childs as $Child) {
#-----------------------------------------------------------------
$Entrance = Tree_Entrance($TableID, (int) $Child['ID']);
#-----------------------------------------------------------------
switch (ValueOf($Entrance)) {
case 'error':
return ERROR | @Trigger_Error('[Tree_Entrance]: не возможно определить дочерние вхождения записей');
case 'exception':
return ERROR | @Trigger_Error('[Tree_Entrance]: запись оказавшаяся дочерней не найдена');
case 'array':
$Result = Array_Merge($Result, $Entrance);
break;
default:
return ERROR | @Trigger_Error(101);
}
}
break;
default:
return ERROR | @Trigger_Error(101);
}
#-----------------------------------------------------------------------
CacheManager::add($CacheID, $Result);
break;
default:
return ERROR | @Trigger_Error(101);
}
}
#-----------------------------------------------------------------------------
return $Result;
}
$WidgetID = SubStr($File, 0, StriPos($File, '.'));
#-------------------------------------------------------------------------
$Comp = Comp_Load(SPrintF('Widgets/%s/%s', $Interface, $WidgetID));
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------
if (Is_Array($Comp)) {
#-----------------------------------------------------------------------
$Comp = Comp_Load('Widget', Md5($WidgetID), $Comp['Title'], $Comp['DOM']);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-----------------------------------------------------------------------
$Td->AddChild($Comp);
}
}
}
#-----------------------------------------------------------------------------
if (!Count($Td->Childs)) {
$Td->AddChild(new Tag('SPAN', array('style' => 'color:#848484;'), 'Виджеты не загружены. Виджет - примитивы графического интерфейса пользователя, имеющие стандартный внешний вид и выполняющие стандартные действия. Виджеты будут автоматически загружаться по мере появления информации в БД.'));
}
#-----------------------------------------------------------------------------
$Out = new Tag('TABLE', array('class' => 'Standard', 'style' => 'background-image:url(SRC:{Images/Grid.png});', 'width' => $Width, 'height' => $Height), new Tag('TR', new Tag('TD', array('height' => '20px', 'style' => 'font-size:11px;color:#DCDCDC;'), 'Рабочая область')), new Tag('TR', $Td));
#-----------------------------------------------------------------------------
CacheManager::add($CacheID, $Out, 3600);
return $Out;
}
#-------------------------------------------------------------------------------
return new Tag('NOBODY', 'User not authorisated...');
#-------------------------------------------------------------------------------
$Result[] = $Event;
#-------------------------------------------------------------------------------
$LastID = $Event['ID'];
#-------------------------------------------------------------------------------
#Debug("[comp/www/API/Events]: last selected ID = " . $LastID);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
CacheManager::add($LastIDCacheID, $LastID, 24 * 3600);
/* на сутки в кэш */
#-------------------------------------------------------------------------------
$Out['Status'] = 'Ok';
$Out['Events'] = $Result;
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
CacheManager::add($TimeCacheID, Time(), 10);
CacheManager::add($OutCacheID, $Out, 10);
#Debug("[comp/www/API/Events]: результат добавлен в кэш");
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#Debug(Print_r($Out,true));
return $Out;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$CacheID = Md5($Path . $GLOBALS['__USER']['ID']);
#-------------------------------------------------------------------------------
$Result = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
if ($Result) {
#-------------------------------------------------------------------------------
$Notes = $Result;
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$Notes = Comp_Load($Path);
if (Is_Error($Notes)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Notes, 60);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
foreach ($Notes as $Note) {
#-------------------------------------------------------------------------------
$MessageID = SPrintF('note_%s_%s', $GLOBALS['__USER']['ID'], SubStr(Md5(JSON_Encode($Note)), 0, 6));
#-------------------------------------------------------------------------------
if (isset($_COOKIE[$MessageID])) {
continue;
}
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Information', $Note, 'Warning', $MessageID);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return ERROR | @Trigger_Error(400);
case 'false':
break;
case 'true':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
$GLOBALS['__USER']['IsAdmin'] = $IsAdmin;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (!isset($GLOBALS['__USER']['IsEmulate'])) {
#-------------------------------------------------------------------------------
$Cached = CacheManager::get(Md5(SPrintF('LastLogon_%s', $User['Email'])));
#-------------------------------------------------------------------------------
if (!$Cached) {
CacheManager::add(Md5(SPrintF('LastLogon_%s', $User['Email'])), array('EnterIP' => $User['EnterIP'], 'EnterDate' => $User['EnterDate']), 15 * 60);
}
#-------------------------------------------------------------------------------
#Debug(SPrintF('[comp/Users/Init]: User[EnterIP] = %s',$User['EnterIP']));
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return $User;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
if ($Code == 'Domain') {
$ColumnName = 'ExpirationDate';
}
#-------------------------------------------------------------------------------
$Order = DB_Select($Table, array($ColumnName), array('UNIQ', 'Where' => $Where));
#-------------------------------------------------------------------------------
switch (ValueOf($Order)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return ERROR | @Trigger_Error(400);
case 'array':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Comp = Comp_Load($CompName, $Order[$ColumnName]);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $Comp, 3600);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return $Comp;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Config = Config();
#-------------------------------------------------------------------------------
$Settings = $Config['Interface']['User']['Orders']['Domain']['DomainWhoIs'];
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$CacheID = Md5(SPrintF('WhoIs-%s.%s', $DomainName, $DomainZone));
#-------------------------------------------------------------------------------
$IsCheck = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
if (!$IsCheck) {
#-------------------------------------------------------------------------------
$IsCheck = WhoIs_Check($DomainName, $DomainZone, $IsAvalible);
#-------------------------------------------------------------------------------
CacheManager::add($CacheID, $IsCheck, IntVal($Settings['CacheTime']));
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
switch (ValueOf($IsCheck)) {
case 'error':
return array('Status' => 'Fail');
case 'exception':
return $IsCheck;
case 'false':
return new gException('DOMAIN_ZONE_NOT_SUPPORTED', 'Доменная зона не поддерживается');
case 'array':
#-------------------------------------------------------------------------------
$IsCheck['Status'] = 'Borrowed';
#-------------------------------------------------------------------------------
return $IsCheck;
/******************************************************************************/
if (Is_Error(System_Load('modules/Authorisation.mod', 'classes/Session.class.php'))) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Session = new Session((string) @$_COOKIE['SessionID']);
#-------------------------------------------------------------------------------
if (Is_Error($Session->Delete())) {
return ERROR | @Trigger_Error(400);
}
#-------------------------------------------------------------------------------
if (!SetCookie('SessionID', 'closed', Time(), '/')) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Event = array('UserID' => $GLOBALS['__USER']['ID'], 'Text' => 'Пользователь вышел из системы');
#-------------------------------------------------------------------------------
$Event = Comp_Load('Events/EventInsert', $Event);
if (!$Event) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
CacheManager::add(Md5(SPrintF('LastLogon_%s', $GLOBALS['__USER']['Email'])), FALSE, 1);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return array('Status' => 'Ok');
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
function WebNames_Get_List_Domains($Settings)
{
/******************************************************************************/
$__args_types = array('array', 'string');
#-------------------------------------------------------------------------------
$__args__ = Func_Get_Args();
eval(FUNCTION_INIT);
/******************************************************************************/
# ввиду того, что вебнеймс интерфейса нормального не предоставляет, а за частые
# запросы банит, кэшируем полученный результат и юазем кэш
$CacheID = Md5(SPrintF('%s-pispAllDomainsInfo', $Settings['Login']));
#-------------------------------------------------------------------------------
$Result = CacheManager::get($CacheID);
#-------------------------------------------------------------------------------
# если результата нет - лезем в вебнеймс
if (!$Result) {
#-------------------------------------------------------------------------------
$HTTP = WebNames_Build_HTTP($Settings);
#-------------------------------------------------------------------------------
$Query = array('thisPage' => 'pispAllDomainsInfo', 'username' => $Settings['Login'], 'password' => $Settings['Password'], 'interface_revision' => 2, 'interface_lang' => 'en');
#-------------------------------------------------------------------------------
$Result = HTTP_Send('/RegTimeSRS.pl', $HTTP, array(), $Query);
if (Is_Error($Result)) {
return ERROR | @Trigger_Error('[WebNames_Get_List_Domains]: не удалось выполнить запрос к серверу');
}
#-------------------------------------------------------------------------------
$Result = Json_Decode($Result['Body'], TRUE);
#-------------------------------------------------------------------------------
#Debug(SPrintF('[system/libs/WebNames.php]: $Result = %s',print_r($Result,true)));
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (isset($Result['error'])) {
return new gException('REGISTRATOR_ERROR', 'Регистратор вернул ошибку');
}
#-------------------------------------------------------------------------------
if (!isset($Result['success'])) {
return ERROR | @Trigger_Error('[WebNames_Get_List_Domains]: неизвестный ответ');
}
#-------------------------------------------------------------------------------
# кэшируем полученный результат
CacheManager::add($CacheID, $Result, 3600);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# перебираем массив, составляем массив на выхлоп функции
$Out = array();
#-------------------------------------------------------------------------------
if (Is_Array($Result['success'])) {
#-------------------------------------------------------------------------------
foreach ($Result['success'] as $Domain) {
#-------------------------------------------------------------------------------
Debug(SPrintF('[system/libs/WebNames.php]: $Domain = %s', print_r($Domain, true)));
#-------------------------------------------------------------------------------
$Out[] = $Domain['dname'];
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (SizeOf($Out)) {
#-------------------------------------------------------------------------------
return array('Status' => 'true', 'Domains' => $Out);
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
return array('Status' => 'false', 'ErrorText' => 'No domains on account');
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
