/**
* Конструктор класса
*
* Создает документ из XML строки.
*
* @param string <иницилиазирующая строка>
*/
public function DOM($Source = NULL)
{
/****************************************************************************/
$__args_types = array('string,object');
#-----------------------------------------------------------------------------
$__args__ = Func_Get_Args();
eval(FUNCTION_INIT);
/****************************************************************************/
if (!Is_Null($Source)) {
#---------------------------------------------------------------------------
if (Is_Object($Source)) {
#-------------------------------------------------------------------------
$this->Object = $Source;
#-------------------------------------------------------------------------
$this->Linking();
}
#---------------------------------------------------------------------------
if (Is_String($Source)) {
#-------------------------------------------------------------------------
if (Mb_StrLen($Source) > 1) {
#-----------------------------------------------------------------------
$this->Object = String_XML_Parse($Source);
if (Is_Exception($this->Object)) {
return ERROR | Trigger_Error('[DOM->DOM]: не удалось преобразовать XML');
}
#-----------------------------------------------------------------------
$this->Object = Current($this->Object->Childs);
#-----------------------------------------------------------------------
$this->Linking();
}
}
}
}
#-------------------------------------------------------------------------------
$Settings = $Config['Interface']['Edesks']['DenyFoulLanguage'];
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$EnCharMap = array("jo", "j", "c", "u", "k", "e", "n", "g", "sh", "sh", "z", "h", "'", "f", "u", "v", "a", "p", "r", "o", "l", "d", "zh", "je", "ja", "ch", "s", "m", "i", "t", "'", "b", "ju");
#-------------------------------------------------------------------------------
# For transliteration russian char map
$RuCharMap = array("ё", "й", "ц", "у", "к", "е", "н", "г", "ш", "щ", "з", "х", "ъ", "ф", "ы", "в", "а", "п", "р", "о", "л", "д", "ж", "э", "я", "ч", "с", "м", "и", "т", "ь", "б", "ю");
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
foreach (Preg_Split('/[\\s,]+/', $Text) as $Word) {
#Debug(SPrintF('[comp/Formats/Edesk/Message/CheckFoul]: Word = "%s"',print_r($Word,true)));
#-------------------------------------------------------------------------------
$Word = Trim(Str_Replace($EnCharMap, $RuCharMap, Mb_StrToLower($Word, 'UTF-8')));
#-------------------------------------------------------------------------------
if (Mb_StrLen($Word) > $Settings['FoulMaxLength']) {
continue;
}
#-------------------------------------------------------------------------------
foreach (Preg_Split('/\\s+/', $Regulars['Fouls']) as $Foul) {
#-------------------------------------------------------------------------------
$Foul = Trim($Foul);
#Debug(SPrintF('[comp/Formats/Edesk/Message/CheckFoul]: Foul = "%s"',print_r($Foul,true)));
#-------------------------------------------------------------------------------
if (Preg_Match($Foul, $Word)) {
#-------------------------------------------------------------------------------
Debug(SPrintF('[comp/Formats/Edesk/Message/CheckFoul]: Foul found: "%s"', $Word));
return array('Word' => $Word);
# нецензурщина детектед
#-------------------------------------------------------------------------------
}
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$Value = 'Список выбора поля';
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
case 'File':
#-------------------------------------------------------------------------------
$FileName = $ServiceOrderField['FileName'];
#-------------------------------------------------------------------------------
if (Mb_StrLen($FileName) > 15) {
$FileName = SPrintF('%s...', Mb_SubStr($FileName, 0, 15));
}
#-------------------------------------------------------------------------------
$Value = new Tag('TD', array('class' => 'Standard'), new Tag('A', array('href' => SPrintF('/OrderFileDownload?OrderFieldID=%u', $ServiceOrderField['ID'])), SPrintF('%s (%01.2f Кб.)', $FileName, StrLen(Base64_Decode($Value)) / 1024)));
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
case 'Hidden':
continue 2;
default:
# No more...
}
#-------------------------------------------------------------------------------
$Fields[] = array($ServiceField['Name'], $Value);
if (Is_Error($Sourse)) {
return ERROR | @Trigger_Error(500);
}
#-----------------------------------------------------------------------------
//if(!Preg_Match('/\.comp.php/',$File))
// continue;
#-----------------------------------------------------------------------------
$Function = isset($Args['RegEx']) ? 'Preg_Replace' : 'Str_Replace';
#-----------------------------------------------------------------------------
$Out = $Function($Search, $Replace, $Sourse);
#-----------------------------------------------------------------------------
if ($Out != $Sourse) {
#---------------------------------------------------------------------------
if ($IsWrite) {
#-------------------------------------------------------------------------
$IsWrite = IO_Write($File, $Out, TRUE);
if (Is_Error($IsWrite)) {
return ERROR | @Trigger_Error(500);
}
}
#---------------------------------------------------------------------------
$Name = Mb_SubStr($File, Mb_StrLen($Folder) + 1);
#---------------------------------------------------------------------------
echo SPrintF("%s\n", $Name);
#---------------------------------------------------------------------------
$Count++;
}
}
#-------------------------------------------------------------------------------
echo SPrintF("Replaced in %s files\n", $Count);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
foreach (Array_Keys($Row) as $ColumnID) {
#-------------------------------------------------------------------------------
$TypeID = $ColumnsTypes[$ColumnID]['Type'];
#-------------------------------------------------------------------------------
$Value = $Row[$ColumnID];
#-------------------------------------------------------------------------------
#Debug(SPrintF('[comp/www/Administrator/RowEdit]: $ColumnID = %s; $Value = %s',$ColumnID,$Value));
#-------------------------------------------------------------------------------
if (Is_Null($Value)) {
$Value = '[NULL]';
}
#-------------------------------------------------------------------------------
if (Preg_Match('/blob/', $TypeID)) {
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Upload', $ColumnID, SPrintF('%01.2f Кб.', Mb_StrLen($Value) / 1024));
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
if (Preg_Match('/(int|float)/', $TypeID)) {
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Form/Input', array('name' => $ColumnID, 'type' => 'text', 'style' => 'width: 100%;', 'value' => (string) $Value));
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
$Args = Args();
#-------------------------------------------------------------------------------
$ClauseFileID = (int) @$Args['ClauseFileID'];
$IsPrintOut = (bool) @$Args['IsPrintOut'];
#-------------------------------------------------------------------------------
$ClauseFile = DB_Select('ClausesFiles', '*', array('UNIQ', 'ID' => $ClauseFileID));
#-------------------------------------------------------------------------------
switch (ValueOf($ClauseFile)) {
case 'error':
return ERROR | @Trigger_Error(500);
case 'exception':
return ERROR | @Trigger_Error(400);
case 'array':
#---------------------------------------------------------------------------
$FileData = $ClauseFile['FileData'];
#---------------------------------------------------------------------------
if (!$IsPrintOut) {
#-------------------------------------------------------------------------
$Length = Mb_StrLen($FileData, 'ASCII');
#-------------------------------------------------------------------------
Header('Content-Type: application/octetstream; charset=utf-8');
Header(SPrintF('Content-Length: %u', $Length));
Header(SPrintF('Content-Disposition: attachment; filename="%s";', $ClauseFile['FileName']));
Header('Pragma: nocache');
}
#---------------------------------------------------------------------------
return $FileData;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
return $Comp;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
case 'array':
#-------------------------------------------------------------------------------
$Table[] = array('Платежная система', $PaymentSystem['Name']);
#-------------------------------------------------------------------------------
$Options = array();
#-------------------------------------------------------------------------------
foreach ($Contracts as $Contract) {
#-------------------------------------------------------------------------------
$Customer = $Contract['Customer'];
#-------------------------------------------------------------------------------
if (Mb_StrLen($Customer) > 20) {
$Customer = SPrintF('%s...', Mb_SubStr($Customer, 0, 20));
}
#-------------------------------------------------------------------------------
$Options[$Contract['ID']] = $Customer;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Form/Select', array('name' => 'ContractID', 'style' => 'width: 100%;'), $Options, $ContractID);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
$Table[] = array('Базовый договор', $Comp);
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
eval(COMP_INIT);
/******************************************************************************/
/******************************************************************************/
$IPs = $ExtraIP ? Explode("\n", $ExtraIP) : array();
#-------------------------------------------------------------------------------
$IPs[] = $IP;
#-------------------------------------------------------------------------------
$IPs = Array_Unique($IPs);
#-------------------------------------------------------------------------------
$Count = Count($IPs);
#-------------------------------------------------------------------------------
if ($Count > 10) {
$IPs = Array_Slice($IPs, 0, 9);
}
#-------------------------------------------------------------------------------
if (Mb_StrLen($IP) > $Length) {
$IP = SPrintF('%s...', Mb_SubStr($IP, 0, $Length));
}
#-------------------------------------------------------------------------------
$A = new Tag('A', array('target' => 'blank', 'href' => SPrintF('http://%s/', $IP)), $IP);
#-------------------------------------------------------------------------------
$LinkID = UniqID('IPs');
#-------------------------------------------------------------------------------
$Links =& Links();
# Коллекция ссылок
$Links[$LinkID] =& $A;
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Form/Prompt', $LinkID, SPrintF('<B>Всего: %u</B><BR />%s', $Count, Implode('<BR />', $IPs)));
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
return ERROR | @Trigger_Error(500);
case 'exception':
return $Rss->ToXMLString();
case 'array':
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
foreach ($Versions as $Version) {
#-------------------------------------------------------------------------------
$Link = SPrintF('http://%s/Rss/New?NewID=%u', HOST_ID, $Version['ID']);
#-------------------------------------------------------------------------------
$Text = Strip_Tags($Version['Text']);
#-------------------------------------------------------------------------------
if (Mb_StrLen($Text) > 120) {
$Text = SPrintF('%s...', Mb_SubStr($Text, 0, 120));
}
#-------------------------------------------------------------------------------
$Item = new Tag('item');
$Item->AddChild(new Tag('guid', $Link));
$Item->AddChild(new Tag('title', $Version['Title']));
$Item->AddChild(new Tag('description', $Text));
$Item->AddChild(new Tag('author', $Email));
$Item->AddChild(new Tag('pubDate', Date('r', $Version['PublicDate'])));
$Item->AddChild(new Tag('link', $Link));
#-------------------------------------------------------------------------------
$Channel->AddChild($Item);
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
function ToXMLString($Level = 0, $IsFormat = TRUE)
{
/****************************************************************************/
$__args_types = array('integer', 'boolean');
#-----------------------------------------------------------------------------
$__args__ = Func_Get_Args();
eval(FUNCTION_INIT);
/****************************************************************************/
$Name = $this->Name;
#-----------------------------------------------------------------------------
$Result = SPrintF('<%s', $Name);
#-----------------------------------------------------------------------------
if ($IsFormat) {
$Result = SPrintF('%s%s', $Level ? Str_Pad(' ', $Level) : '', $Result);
}
#-----------------------------------------------------------------------------
$Attribs = $this->Attribs;
#-----------------------------------------------------------------------------
foreach (Array_Keys($Attribs) as $AttribID) {
$Result .= SPrintF(' %s="%s"', $AttribID, HtmlSpecialChars((string) $Attribs[$AttribID]));
}
#-----------------------------------------------------------------------------
$Childs = $this->Childs;
#-----------------------------------------------------------------------------
if (Count($Childs)) {
#---------------------------------------------------------------------------
$Result .= '>';
#---------------------------------------------------------------------------
$IsNoCData = TRUE;
#---------------------------------------------------------------------------
foreach ($Childs as $Child) {
#-------------------------------------------------------------------------
if (In_Array($Child->Name, array('CDATA'))) {
#-----------------------------------------------------------------------
$IsNoCData = FALSE;
#-----------------------------------------------------------------------
break;
}
}
#---------------------------------------------------------------------------
$Nodes = '';
#---------------------------------------------------------------------------
foreach ($Childs as $Child) {
$Nodes .= In_Array($Child->Name, array('CDATA')) ? HtmlSpecialChars($Child->Text) : $Child->ToXMLString($Level + 1, $IsNoCData);
}
#---------------------------------------------------------------------------
$Result .= $IsNoCData ? SPrintF("\n%s%s", $Nodes, $Level ? Str_Pad(' ', $Level) : '') : $Nodes;
} else {
#---------------------------------------------------------------------------
$Text = isset($Attribs['force-escape']) ? $this->Text : HtmlSpecialChars($this->Text);
#---------------------------------------------------------------------------
$IsShort = !Mb_StrLen($Text) && !In_Array($Name, array('TEXTAREA', 'BUTTON', 'TITLE', 'SCRIPT', 'TABLE', 'TD', 'TR'));
#---------------------------------------------------------------------------
if ($IsShort) {
#-------------------------------------------------------------------------
$Result .= ' />';
#-------------------------------------------------------------------------
if ($IsFormat) {
$Result .= "\n";
}
#-------------------------------------------------------------------------
return $Result;
} else {
$Result .= SPrintF('>%s', $Text);
}
}
#-----------------------------------------------------------------------------
$Result .= SPrintF('</%s>', $Name);
#-----------------------------------------------------------------------------
if ($IsFormat) {
$Result .= "\n";
}
#-----------------------------------------------------------------------------
return $Result;
}
/******************************************************************************/
$Domains = $Parked ? Explode(',', $Parked) : array();
#-------------------------------------------------------------------------------
$Domains[] = $Domain;
#-------------------------------------------------------------------------------
$Domains = Array_Unique($Domains);
#-------------------------------------------------------------------------------
$Count = Count($Domains);
#-------------------------------------------------------------------------------
if ($Count > 10) {
$Domains = Array_Slice($Domains, 0, 9);
}
#-------------------------------------------------------------------------------
$Domain = $Text = Current($Domains);
#-------------------------------------------------------------------------------
if (Mb_StrLen($Text) > $Length) {
$Text = SPrintF('%s...', Mb_SubStr($Text, 0, $Length));
}
#-------------------------------------------------------------------------------
$A = new Tag('A', array('target' => 'blank', 'href' => SPrintF('http://%s/', $Domain)), $Text);
#-------------------------------------------------------------------------------
$LinkID = UniqID('Domains');
#-------------------------------------------------------------------------------
$Links =& Links();
# Коллекция ссылок
$Links[$LinkID] =& $A;
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Form/Prompt', $LinkID, SPrintF('<B>Всего: %u</B><BR />%s', $Count, Implode('<BR />', $Domains)));
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
function IO_Read($Path, $IsUseLinks = TRUE)
{
/******************************************************************************/
$__args_types = array('string', 'boolean');
#-------------------------------------------------------------------------------
$__args__ = Func_Get_Args();
eval(FUNCTION_INIT);
/******************************************************************************/
Debug(SPrintF('[IO_Read]: открытие файла (%s)', $Path));
#-------------------------------------------------------------------------------
if (!File_Exists($Path)) {
return ERROR | @Trigger_Error('[IO_Read]: файл не существует');
}
#-------------------------------------------------------------------------------
if (!($File = @Fopen($Path, 'r'))) {
return ERROR | @Trigger_Error('[IO_Read]: ошибка открытия файла');
}
#-------------------------------------------------------------------------------
$Size = @FileSize($Path);
if (!$Size) {
return '';
}
#-------------------------------------------------------------------------------
if (!($Result = @Fread($File, $Size))) {
return ERROR | @Trigger_Error('[IO_Read]: ошибка чтения файла');
}
#-------------------------------------------------------------------------------
if (!Fclose($File)) {
return ERROR | @Trigger_Error('[IO_Read]: ошибка закрытия файла');
}
#-------------------------------------------------------------------------------
if (Mb_StrLen($Result) > 4) {
#-------------------------------------------------------------------------------
if (Mb_SubStr($Result, 1, 4) == 'link' && $IsUseLinks) {
#-------------------------------------------------------------------------------
$LinkPath = Trim(Mb_SubStr($Result, Mb_StrPos($Result, ':') + 1));
#-------------------------------------------------------------------------------
switch ($Result[0]) {
case '#':
# Абсолюная ссылка
# No more...
break;
case '@':
# Относительная ссылка
#-------------------------------------------------------------------------------
$Folder = Mb_SubStr($Path, 0, Mb_StrrPos($Path, '/'));
#-------------------------------------------------------------------------------
$LinkPath = SPrintF('%s/%s', $Folder, $LinkPath);
#-------------------------------------------------------------------------------
break;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
default:
return ERROR | @Trigger_Error('[IO_Read]: тип ссылки не определён');
}
#-------------------------------------------------------------------------------
if ($Path == $LinkPath) {
return ERROR | @Trigger_Error(SPrintF('[IO_Read]: ссылка сама на себя в файле(%s)', $Path));
}
#-------------------------------------------------------------------------------
Debug(SPrintF('[IO_Read]: символическая ссылка (%s) на (%s)', $Path, $LinkPath));
#-------------------------------------------------------------------------------
$Result = IO_Read($LinkPath);
if (Is_Error($Result)) {
return ERROR | @Trigger_Error('[IO_Read]: ошибка рекурсивного вызова');
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
return $Result;
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
}
/** @author Великодный В.В. (Joonte Ltd.) */
/******************************************************************************/
/******************************************************************************/
$__args_list = array('Value', 'Length', 'Url', 'IsHtmlEncode');
/******************************************************************************/
eval(COMP_INIT);
/******************************************************************************/
/******************************************************************************/
#Debug(SPrintF('[comp/Formats/String]: Value = %s; Length = %s; Url = %s',$Value,$Length,$Url));
#-------------------------------------------------------------------------------
if ($IsHtmlEncode) {
$Value = HtmlSpecialChars($Value);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (Mb_StrLen($Value) > $Length) {
#-------------------------------------------------------------------------------
$Text = Mb_SubStr($Value, 0, $Length);
#-------------------------------------------------------------------------------
$Result = Is_Null($Url) ? new Tag('SPAN', SPrintF('%s...', $Text)) : new Tag('A', array('href' => $Url, 'target' => 'blank'), SPrintF('%s...', $Text));
#-------------------------------------------------------------------------------
$LinkID = UniqID('String');
#-------------------------------------------------------------------------------
$Links =& Links();
#-------------------------------------------------------------------------------
$Links[$LinkID] =& $Result;
#-------------------------------------------------------------------------------
$Comp = Comp_Load('Form/Prompt', $LinkID, $Value);
if (Is_Error($Comp)) {
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;
#-------------------------------------------------------------------------------
}
# truncate $Theme & $Message
$Theme = substr($Theme, 0, 127);
$Message = substr($Message, 0, 62000);
#-------------------------------------------------------------------------------
if (Is_Error(System_Load('modules/Authorisation.mod', 'libs/Upload.php'))) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Config = Config();
#-------------------------------------------------------------------------------
if (!$Theme) {
return new gException('THEME_IS_EMPTY', 'Введите тему запроса');
}
#-------------------------------------------------------------------------------
if (Mb_StrLen(Count_Chars($Theme, 3)) < $Config['Interface']['Edesks']['ThemeMinimumLength']) {
return new gException('THEME_IS_TOO_SHORT', 'Некорректная тема запроса');
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Priorities = $Config['Edesks']['Priorities'];
#-------------------------------------------------------------------------------
if (!In_Array($PriorityID, Array_Keys($Priorities))) {
return new gException('WRONG_PRIORITY', 'Неверный приоритет запроса');
}
#-------------------------------------------------------------------------------
if (!$Message) {
return new gException('MESSAGE_IS_EMPTY', 'Введите сообщение запроса');
}
#-------------------------------------------------------------------------------
$Count = DB_Count('Groups', array('ID' => $TargetGroupID));
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;
}
#-------------------------------------------------------------------------------
$Result = "qiwi" . Str_Pad($Settings['Send']['from'], 10, "0", STR_PAD_LEFT) . "\n";
#-------------------------------------------------------------------------------
$Result .= base64_encode($crypted);
#-------------------------------------------------------------------------------
# send message to QIWI server
$HTTP = array('Protocol' => $Settings['Send']['UseSSL'] ? 'ssl' : 'tcp', 'Port' => $Settings['Send']['UseSSL'] ? '443' : '80', 'Address' => 'ishop.qiwi.ru', 'Host' => 'ishop.qiwi.ru', 'IsLogging' => $Settings['IsLogging']);
#-------------------------------------------------------------------------------
$Send = HTTP_Send('/xml', $HTTP, array(), $Result, array('Content-type: text/xml; encoding=utf-8'));
#-------------------------------------------------------------------------------
if (Is_Error($Send)) {
return TRUE;
}
#-------------------------------------------------------------------------------
# parse XML
if (Mb_StrLen($Send['Body']) == 0) {
#-------------------------------------------------------------------------------
Debug(SPrintF('[comp/comp/Tasks/GC/QIWI]: Body zero size'));
#-------------------------------------------------------------------------------
return TRUE;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
$XML = String_XML_Parse($Send['Body']);
if (Is_Exception($XML)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
$Response = Trim($Send['Body']);
#-------------------------------------------------------------------------------
$XML = String_XML_Parse($Response);
#-------------------------------------------------------------------------------
$Number = Comp_Load('Formats/Order/Number', $ServiceOrderID);
if (Is_Error($Number)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Settings = @$Order['Params']['Statuses']['OnCreate'];
#-------------------------------------------------------------------------------
# проверяем, надо ли выполнять задачу
if (isset($Settings['IsNoAction']) && $Settings['IsNoAction'] == 'yes') {
return TRUE;
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (isset($Settings['Script']) && Mb_StrLen(Trim($Settings['Script'])) > 0) {
#-------------------------------------------------------------------------------
$File = Trim($Settings['Script']);
#-------------------------------------------------------------------------------
Debug(SPrintF('[comp/Tasks/ServiceCreate]: Script = %s', $File));
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
if (IntVal($Order['ServerID']) == 0) {
return new gException('SERVER_NOT_SET', 'Для услуги не задан сервер размещения, скрипт не может быть выполнен. Создайте для услуги группу серверов, назначьте в неё сервер, после чего сделайте заказ заново');
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
# находим полный путь к файлу
if (SubStr($File, 0, 1) != '/') {
$File = SPrintF('%s/hosts/%s/scripts/%s', SYSTEM_PATH, HOST_ID, $File);
}
if (Count($Contracts) < 2) {
return FALSE;
}
#---------------------------------------------------------------------------
$Options = array('Default' => 'Все договора');
#---------------------------------------------------------------------------
foreach ($Contracts as $Contract) {
#-------------------------------------------------------------------------
$Comp = Comp_Load('Formats/Contract/Number', $Contract['ID']);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-------------------------------------------------------------------------
$Customer = SPrintF('%s %s', $Comp, $Contract['Customer']);
#-------------------------------------------------------------------------
if (Mb_StrLen($Customer) > 40) {
$Customer = SPrintF('%s...', Mb_SubStr($Customer, 0, 30));
}
#-------------------------------------------------------------------------
$Options[$Contract['ID']] = $Customer;
}
break;
default:
return ERROR | @Trigger_Error(101);
}
#-------------------------------------------------------------------------------
if (!isset($Options[$ContractID])) {
$ContractID = 'Default';
}
#-------------------------------------------------------------------------------
if ($ContractID != 'Default') {
<?php
#-------------------------------------------------------------------------------
/** @author Великодный В.В. (Joonte Ltd.) */
/******************************************************************************/
/******************************************************************************/
$__args_list = array('Domain', 'Zone', 'Length', 'DomainZone');
/******************************************************************************/
eval(COMP_INIT);
/******************************************************************************/
/******************************************************************************/
#-------------------------------------------------------------------------------
if (Mb_StrLen($Domain) > $Length) {
$Domain1 = SPrintF('%s...', Mb_SubStr($Domain, 0, $Length));
} else {
$Domain1 = $Domain;
}
#-------------------------------------------------------------------------------
$A = new Tag('A', array('target' => 'blank', 'href' => SPrintF('http://%s.%s/', $Domain, $DomainZone), 'title' => 'Перейти на сайт'), $Domain1);
#-------------------------------------------------------------------------------
return $A;
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#return new gException('NAME_NS3_NOT_FILL','Укажите имя дополнительного сервера имен');
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
#-------------------------------------------------------------------------------
$Ns4Name = Trim(Mb_StrToLower($Ns4Name, 'UTF-8'), '.');
#-------------------------------------------------------------------------------
if ($Ns4Name) {
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars['DnsDomain'], $Ns4Name)) {
return new gException('WRONG_NAME_NS4', 'Неверное имя расширенного сервера имен');
}
#-------------------------------------------------------------------------------
if (Mb_SubStr($Ns4Name, -Mb_StrLen($Domain)) == $Domain) {
#-------------------------------------------------------------------------------
if (!Preg_Match($Regulars['IP'], $Ns4IP)) {
return new gException('WRONG_IP_NS4', 'Неверный IP адрес расширенного сервера имен');
}
#-------------------------------------------------------------------------------
} else {
#-------------------------------------------------------------------------------
if ($Ns4IP) {
$Ns4IP = '';
}
#-------------------------------------------------------------------------------
#return new gException('IP_NS4_CAN_NOT_FILL','IP адрес расширенного сервера имен не может быть указан');
#-------------------------------------------------------------------------------
}
#-------------------------------------------------------------------------------
case 'exception':
return new gException('PROFILES_NOT_FOUND', 'Профили клиента не найдены');
case 'array':
#-----------------------------------------------------------------------
$Options = array();
#-----------------------------------------------------------------------
foreach ($Profiles as $Profile) {
#---------------------------------------------------------------------
$Comp = Comp_Load('Formats/Profile/Number', $Profile['ID']);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#---------------------------------------------------------------------
$Name = SPrintF('%s - %s', $Comp, $Profile['Name']);
#---------------------------------------------------------------------
if (Mb_StrLen($Name) > 30) {
$Name = SPrintF('%s...', Mb_SubStr($Name, 0, 30));
}
#---------------------------------------------------------------------
$Options[$Profile['ID']] = $Name;
}
#-----------------------------------------------------------------------
$Comp = Comp_Load('Form/Select', array('name' => 'ProfileID', 'style' => 'width:100%'), $Options, $Contract['ProfileID']);
if (Is_Error($Comp)) {
return ERROR | @Trigger_Error(500);
}
#-----------------------------------------------------------------------
$Table[] = array('Профиль', $Comp);
#-----------------------------------------------------------------------
$Comp = Comp_Load('Form/Input', array('name' => 'IsEnclosures', 'type' => 'checkbox', 'value' => 'yes'));
if (Is_Error($Comp)) {
