public function StartThread($module_info)
{
// Reopen database connection in child process
$db = Core::GetDBInstance(null, true);
// Attach mail notifications on registy events
Registry::AttachClassObserver(new EmailToRegistrantObserver());
Registry::AttachClassObserver(new OperationHistory());
Registry::AttachClassObserver(new ManagedDNSRegistryObserver());
$RegFactory = RegistryModuleFactory::GetInstance();
$Registry = $RegFactory->GetRegistryByName($module_info["name"], false);
$Extensions = $Registry->GetManifest()->GetExtensionList();
foreach ($Extensions as $ext)
{
try
{
$r = false;
$r = $RegFactory->GetRegistryByExtension($ext, true, true);
}
catch(Exception $e)
{
$r = false;
}
if ($r && $r->GetModuleName() == $Registry->GetModuleName())
{
Log::Log(sprintf("Processing %s extension with module %s", $ext, $r->GetModuleName()), E_USER_NOTICE);
$r->DispatchPendingOperations();
}
}
}
public function ConvertContacts()
{
$contact_data = $this->DbOld->GetAll('SELECT * FROM contacts');
$ok = $fail = 0;
foreach ($contact_data as $i => $contact_row) {
$imported = (int) $this->DbNew->GetOne('SELECT COUNT(*) FROM contacts WHERE clid = ?', array($contact_row['clid']));
if ($imported) {
// Skip contact, that was imported with domain in $this->ConvertActiveDomains
continue;
}
$this->Log(sprintf('Import contact %s', $contact_row['clid']));
if ($contact_row['type'] == 'bill') {
$contact_row['type'] = CONTACT_TYPE::BILLING;
}
$Registry = $this->RegistryFactory->GetRegistryByExtension($contact_row['TLD'], $db_check = false);
$Contact = $Registry->NewContactInstance($contact_row['type']);
$Contact->CLID = $contact_row['clid'];
$Contact->AuthCode = $contact_row['pw'];
$Contact->UserID = $contact_row['userid'];
try {
$Contact = $Registry->GetRemoteContact($Contact);
$this->DBContact->Save($Contact);
$ok++;
} catch (Exception $e) {
$this->Log($e->getMessage(), E_USER_ERROR);
$fail++;
}
}
$this->Log(sprintf("Imported: %s; Failed: %s", $ok, $fail));
}
/**
* @return RegistryModuleFactory
*/
public static function GetInstance()
{
if (self::$Instance === null) {
self::$Instance = new RegistryModuleFactory();
}
return self::$Instance;
}
function testBusy()
{
//
$factory = RegistryModuleFactory::GetInstance();
$r1 = $factory->GetRegistryByExtension('kz');
$r2 = $factory->GetRegistryByExtension('gov.kz');
$c1 = $r1->NewContactInstanceByGroup('generic');
$c2 = $r2->NewContactInstanceByGroup('generic');
var_dump($c2->ModuleName);
var_dump($c2->SectionName);
var_dump($c2->TargetIndex);
$this->assertTrue($c1->ModuleName == 'DotKZ' && $c1->SectionName == 'all' && $c1->TargetIndex == 0);
$this->assertTrue($c2->ModuleName == 'DotKZ' && $c2->SectionName == 'all' && $c2->TargetIndex == 1);
}
function __construct()
{
$this->UnitTestCase('Verisign registry test');
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension("com");
/*
// OT&E1
$DataForm = new DataForm();
$DataForm->AppendField(new DataFormField('ServerHost', 'text', null, null, null, null, 'web3.hostdad.com'));
$DataForm->AppendField(new DataFormField('Login', 'text', null, null, null, null, 'bindrop1-admin'));
$DataForm->AppendField(new DataFormField('Password', 'text', null, null, null, null, 'fR3#w$9aT*'));
$DataForm->AppendField(new DataFormField('ServerPort', 'text', null, null, null, null, '703'));
$DataForm->AppendField(new DataFormField('SSLCertPath', 'text', null, null, null, null, '/home/marat/webdev/epp-drs/branches/v1000/app/modules/registries/Verisign/ssl/certchain.pem'));
$DataForm->AppendField(new DataFormField('SSLCertPass', 'text', null, null, null, null, ''));
$Module = new VerisignRegistryModule();
$Module->InitializeModule('com', $DataForm);
$this->Registry = new Registry($Module);
// OT&E2
$DataForm2 = new DataForm();
$DataForm2->AppendField(new DataFormField('ServerHost', 'text', null, null, null, null, 'web3.hostdad.com'));
$DataForm2->AppendField(new DataFormField('Login', 'text', null, null, null, null, 'bindrop2-admin'));
$DataForm2->AppendField(new DataFormField('Password', 'text', null, null, null, null, 'KUGHf78e3hfna#'));
// $DataForm2->GetFieldByName('Login')->Value = 'bindrop2-admin';
// $DataForm2->GetFieldByName('Password')->Value = 'KUGHf78e3hfna#';
$DataForm2->AppendField(new DataFormField('ServerPort', 'text', null, null, null, null, '703'));
$DataForm2->AppendField(new DataFormField('SSLCertPath', 'text', null, null, null, null, '/home/marat/webdev/epp-drs/branches/v1000/app/modules/registries/Verisign/ssl/certchain.pem'));
$DataForm2->AppendField(new DataFormField('SSLCertPass', 'text', null, null, null, null, ''));
$Module2 = new VerisignRegistryModule();
$Module2->InitializeModule('com', $DataForm2);
$this->Registry2 = new Registry($Module2);
$DataForm3 = new DataForm();
$DataForm3->AppendField(new DataFormField('ServerHost', 'text', null, null, null, null, 'web3.hostdad.com'));
$DataForm3->AppendField(new DataFormField('Login', 'text', null, null, null, null, 'bindrop-admin'));
$DataForm3->AppendField(new DataFormField('Password', 'text', null, null, null, null, '9WcV5!AC'));
$DataForm3->AppendField(new DataFormField('ServerPort', 'text', null, null, null, null, '700'));
$DataForm3->AppendField(new DataFormField('SSLCertPath', 'text', null, null, null, null, '/home/marat/webdev/epp-drs/branches/v1000/app/modules/registries/Verisign/ssl/certchain.pem'));
$DataForm3->AppendField(new DataFormField('SSLCertPass', 'text', null, null, null, null, ''));
$Module3 = new VerisignRegistryModule();
$Module3->InitializeModule('com', $DataForm3);
$this->ProdRegistry = new Registry($Module3);
//$this->Registry = $this->ProdRegistry;
*/
}
function setUp()
{
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByName("Enom");
return;
$Config = EnomRegistryModule::GetConfigurationForm();
$config_fields = $Config->ListFields();
$config_fields['Login']->Value = 'webta';
$config_fields['Password']->Value = 'UpAkior5';
$config_fields['ServerHost']->Value = 'http://resellertest.enom.com/interface.asp';
$Module = new EnomRegistryModule();
$Module->InitializeModule('mobi', $Config);
$this->Registry = new Registry($Module);
$this->Module = $Module;
$this->contact_fields = array('FirstName' => 'marat', 'LastName' => 'komarov', 'OrganizationName' => 'webta', 'JobTitle' => 'Mr', 'Address1' => 'Testing str. 80', 'City' => 'Sebastopol', 'StateProvinceChoice' => 'P', 'StateProvince' => 'Crimea', 'PostalCode' => '99009', 'Country' => 'UA', 'EmailAddress' => '*****@*****.**', 'Phone' => '+33-131-2312', 'Fax' => '+33-123-1231');
$this->tech_contact_fields = array('FirstName' => 'nikolas123', 'LastName' => 'toursky', 'OrganizationName' => 'webta', 'JobTitle' => 'Mr', 'Address1' => 'Testing str. 80', 'City' => 'Sebastopol', 'StateProvinceChoice' => 'P', 'StateProvince' => 'Crimea', 'PostalCode' => '99009', 'Country' => 'UA', 'EmailAddress' => '*****@*****.**', 'Phone' => '+33-131-2312', 'Fax' => '+33-123-1231');
}
function setUp()
{
// primary registry
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByName('EPPLU');
$this->Registry->AttachObserver(new EmailToRegistrantObserver());
/*
// secondary registry
$DataForm = new DataForm();
$DataForm->AppendField(new DataFormField('ServerHost', 'text', null, null, null, null, 'epp-test.dns.lu'));
$DataForm->AppendField(new DataFormField('Login', 'text', null, null, null, null, 'alutashop_2'));
$DataForm->AppendField(new DataFormField('Password', 'text', null, null, null, null, 'uBds9fn3hmLdf'));
$DataForm->AppendField(new DataFormField('ServerPort', 'text', null, null, null, null, '1703'));
$LURegistry = new EPPLURegistryModule();
$LURegistry->InitializeModule('lu', $DataForm);
$this->Registry2 = new Registry($LURegistry);
*/
}
public function Run($userid)
{
try {
$Factory = RegistryModuleFactory::GetInstance();
$Registry = $Factory->GetRegistryByExtension($this->Domain->Extension);
$host_as_attr = (bool) $Registry->GetManifest()->GetRegistryOptions()->ability->hostattr;
} catch (Exception $e) {
throw new UpdateDomainNameserversAction_Exception(sprintf(_("Cannot change nameservers. Reason: %s"), $e->getMessage()));
}
// Check that all nameserver hosts are registered
foreach ($this->nslist as &$NS) {
$glue_record = preg_match("/^(.*)\\.{$this->Domain->GetHostName()}\$/", $NS->HostName, $matches);
if ($glue_record) {
$known_ns = $this->Db->GetRow("SELECT * FROM nhosts WHERE hostname=? AND domainid=?", array($matches[1], $this->Domain->ID));
if (!$known_ns) {
if ($host_as_attr) {
// No need to register nameserver hosts
$this->Db->Execute("INSERT INTO nhosts SET domainid = ?, hostname = ?, ipaddr = ?", array($this->Domain->ID, $matches[1], $NS->IPAddr));
} else {
throw new UpdateDomainNameserversAction_Exception(sprintf(_("Nameserver %s does not exist"), $NS->HostName), UpdateDomainNameserversAction_Exception::NAMESERVERHOST_NOT_REGISTERED);
}
} else {
$NS = new NameserverHost($NS->HostName, $host_as_attr ? $NS->IPAddr : $known_ns['ipaddr']);
$NS->ID = $known_ns['id'];
}
}
}
// Perform nameservers update
try {
$Changes = new Changelist($this->Domain->GetNameserverList(), $this->nslist);
$Registry->UpdateDomainNameservers($this->Domain, $Changes);
$DBNSHost = DBNameserverHost::GetInstance();
$DBNSHost->SaveList($this->Domain->GetNameserverHostList(), $this->Domain->ID);
return $this->Domain->HasPendingOperation(Registry::OP_UPDATE) ? UpdateDomainNameserversAction_Result::PENDING : UpdateDomainNameserversAction_Result::OK;
} catch (Exception $e) {
throw new UpdateDomainNameserversAction_Exception(sprintf(_("Cannot change nameservers. Reason: %s"), $e->getMessage()));
}
}
public function __construct($config)
{
$Ref = new ReflectionObject($this);
foreach ($config as $k => $v) {
if ($Ref->hasProperty($k)) {
$this->{$k} = $v;
}
}
// Data validation
if (!($this->tld || $this->Registry)) {
throw new LogicException('$tld or $Registry must be defined');
}
if (!$this->userid) {
throw new LogicException('Property $userid is undefined');
}
// Initialization
$this->Db = Core::GetDBInstance();
if (!$this->Registry) {
$Factory = RegistryModuleFactory::GetInstance();
try {
$this->Registry = $Factory->GetRegistryByExtension($this->tld);
} catch (Exception $e) {
throw new RuntimeException(sprintf(_("Cannot init registry module. Reason: %s"), $e->getMessage()));
}
} else {
$this->tld = $this->Registry->GetModule()->Extension;
}
if (!$this->form_title) {
$this->form_title = _("Select contacts");
}
if (!$this->button_text) {
$this->button_text = _("Next");
}
if (!$this->defer_render) {
$this->Render();
}
}
function setUp ()
{
// Battle account init
$this->registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension("ch");
return;
// Test module init
$Config = EPPCHRegistryModule::GetConfigurationForm();
$fields = $Config->ListFields();
/*
$fields['Login']->Value = 'TEST-PARTNER-A';
//$fields['Password']->Value = 'TEST-PARTNER-A-p';
$fields['Password']->Value = 'qwerty123456_';
*/
/*
$fields['Login']->Value = 'TEST-PARTNER-B';
$fields['Password']->Value = 'epp-test-%2A';
*/
$fields['Login']->Value = 'TEST-PARTNER-C';
$fields['Password']->Value = 'epp-test-pwd';
$fields['ServerHost']->Value = 'diedomainer.com';
$fields['ServerPort']->Value = '7001';
$Module = new EPPCHRegistryModule();
$Module->InitializeModule('ch', $Config);
$this->registry = new Registry($Module);
}
<?php
require_once 'src/prepend.inc.php';
$stepno = $post_stepno;
if (!$stepno) {
$stepno = 1;
}
if ($_POST) {
$RegFactory = RegistryModuleFactory::GetInstance();
if ($stepno == 1) {
// Accept selected TLD
try {
$Registry = $RegFactory->GetRegistryByExtension($post_TLD);
$_SESSION['BU_TLD'] = $post_TLD;
$stepno = 2;
} catch (Exception $e) {
$errmsg = sprintf(_("Registry module not defined for %s domain extension"), $post_TLD);
}
} else {
if ($stepno == 2) {
// Accept selected domains
if (!empty($post_domains)) {
$_SESSION['BU_DOMAINS'] = $post_domains;
$stepno = 3;
} else {
$errmsg = sprintf(_("No domains were selected"));
}
} else {
if ($stepno == 3) {
// Accept selected contacts and create pending update operation
foreach (array($post_registrant, $post_admin, $post_billing, $post_tech) as $clid) {
private function CreateObject($row, RegistryManifest $registry_manifest = null)
{
// TODO:
// Remove cross-reference to Registry
$RegFactory = RegistryModuleFactory::GetInstance();
if ($row['TLD']) {
$registry = $RegFactory->GetRegistryByExtension($row['TLD']);
} else {
$Manifest = new RegistryManifest(sprintf('%s/registries/%s/module.xml', MODULES_PATH, $row['module_name']));
$registryOptions = $Manifest->GetRegistryOptions();
if ((bool) $registryOptions->ability->section_shared_contacts) {
// Contacts shared between sections. i.e. contact is suitable for all TLDs
$rows = $this->DB->GetAll("SELECT tld FROM tlds WHERE modulename = ? AND isactive = 1", array($row['module_name']));
$tlds = array();
foreach ($rows as $_r) {
$tlds[] = $_r['tld'];
}
} else {
$Manifest->SetSection($row['section_name']);
list($target) = $Manifest->GetSectionConfig()->xpath(sprintf("contact_groups/group[@name='%s']/targets/target[%d]", $row['groupname'], $row['target_index'] + 1));
if (!$target) {
throw new ApplicationException(sprintf(_("Error in module manifest. Cannot find corresponding contact group for %s:%s"), $row['groupname'], $row['target_index'] + 1));
}
$tlds = explode(',', $target->attributes()->tlds);
if (!$tlds) {
throw new ApplicationException(sprintf(_("Error in module manifest. Contact target tlds attribute is empty. " . "Module=%s, SectionName=%s, Index=%s"), $row["module_name"], $row["section_name"], $row['target_index']));
}
// Ugly hack that helps contact to find it's configured module
$in = array();
foreach ($tlds as $tld) {
$in[] = "'{$tld}'";
}
$tldrows = $this->DB->GetAll("SELECT TLD FROM tlds WHERE isactive=? AND modulename=? AND TLD IN (" . join(",", $in) . ")", array("1", $row['module_name']));
$tlds = array();
foreach ($tldrows as $tldrow) {
$tlds[] = $tldrow["TLD"];
}
}
foreach ($tlds as $tld) {
try {
$registry = $RegFactory->GetRegistryByExtension($tld);
break;
} catch (Exception $e) {
// TODO:
// This may caught when tld going first in section is inactive.
// Dirty bug itself. We must solve it
Log::Log("Cannot load contact. tld={$tld} message=" . $e->getMessage(), E_USER_ERROR);
}
}
if (!$registry) {
throw new ApplicationException(sprintf(_("Cannot find registry object, that can handle contact ID=%d"), $row["id"]));
}
}
$contact = $registry->NewContactInstanceByGroup($row['groupname']);
$contact->Registry = $registry;
// Map fields to properties
foreach ($this->FieldPropertyMap as $field => $property) {
$contact->{$property} = $row[$field];
}
$disclose_data = $this->DB->GetAll('SELECT * FROM contacts_discloses WHERE contactid = ?', array($contact->CLID));
foreach ($disclose_data as $disclose_row) {
$contact->SetDiscloseValue($disclose_row['field_name'], (int) $disclose_row['value']);
}
// Load contact fields
//$contact_fields = $registry_manifest->GetContactFields($contact->Type);
$contact_data = $this->DB->GetAll('SELECT * FROM contacts_data WHERE contactid = ?', array($contact->CLID));
$buf = array();
foreach ($contact_data as $contact_row) {
//if (in_array($contact_row['field'], $contact_fields))
$buf[$contact_row['field']] = $contact_row['value'];
}
try {
$contact->SetFieldList($buf, (bool) $row['strict_fields']);
} catch (ErrorList $e) {
Log::Log(sprintf("Strict data validation failed for contact %s. Marking this contact as non-strictly validated.", $contact->CLID), E_USER_WARNING);
Log::Log(join('; ', $e->GetAllMessages()), E_USER_WARNING);
$contact->SetFieldList($buf, false);
}
// Extra stored data is diff between raw contact fields and manifset's defined fields
$contact->ExtraStoredData = array_diff_key($buf, $contact->GetFieldList());
// Add pending operations to contact
$operations = $this->DB->GetAll("SELECT * FROM pending_operations WHERE objecttype='CONTACT' AND objectid=?", array($contact->ID));
foreach ($operations as $op) {
$contact->AddPendingOperation($op["operation"]);
}
// Add contact to loaded objects storage
$this->LoadedObjects[$contact->ID] = clone $contact;
return $contact;
}
private function CreateObject($row, RegistryManifest $registry_manifest = null)
{
/*
if ($registry_manifest == null)
{
$registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($row['TLD']);
$registry_manifest = $registry->GetManifest();
unset($registry);
}
*/
// TODO
// ���������� ���������� �� ������������ ������, ���� ������� ���� ��������
// ��������� ������� Domain
//
$registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($row['TLD']);
if (!$registry) {
throw new Exception(sprintf(_("Registry module not defined for '%s' domain extension"), $row['TLD']));
}
$domain = $registry->NewDomainInstance();
$registry_manifest = $registry->GetManifest();
//unset($registry);
// Normalize DB data
$row['start_date'] = strtotime($row['start_date']);
$row['end_date'] = strtotime($row['end_date']);
$row['dtTransfer'] = strtotime($row['dtTransfer']);
$row["islocked"] = (bool) $row["islocked"];
$row['managed_dns'] = (bool) $row['managed_dns'];
// Normalize nameservers data
$ns_arr = array();
if ($row['ns1']) {
$ns_arr[] = $row['ns1'];
}
if ($row['ns2']) {
$ns_arr[] = $row['ns2'];
}
if ($row['ns_n']) {
$ns_n = array_map('trim', explode(';', $row['ns_n']));
foreach ($ns_n as $hostname) {
$ns_arr[] = $hostname;
}
}
// Load glue records
$arr = $this->DB->GetAll('SELECT * FROM nhosts WHERE domainid = ?', array($row['id']));
$glue_records = array();
foreach ($arr as $tmp) {
$glue_records["{$tmp['hostname']}.{$row['name']}.{$row['TLD']}"] = $tmp;
}
// Create nameservers list
$nslist = array();
foreach ($ns_arr as $hostname) {
// Check that nameserver is glue record.
if (FQDN::IsSubdomain($hostname, "{$row["name"]}.{$row["TLD"]}") && array_key_exists($hostname, $glue_records)) {
$nshost = new NameserverHost($hostname, $glue_records[$hostname]['ipaddr']);
$nshost->ID = $glue_records[$hostname]['id'];
$nslist[] = $nshost;
} else {
$nslist[] = new Nameserver($hostname);
}
}
// Map fields to properties
foreach ($this->FieldPropertyMap as $field => $property) {
$domain->{$property} = $row[$field];
}
// Set nameservers
$domain->SetNameserverList($nslist);
// Load extra fields
$extra_fields = $this->DB->GetAll('SELECT `key`, `value` FROM domains_data WHERE domainid = ?', array($domain->ID));
foreach ($extra_fields as $ext_row) {
$domain->{$ext_row['key']} = $ext_row['value'];
$domain->SetExtraField($ext_row['key'], $ext_row['value']);
}
// Load flags
$flags_data = $this->DB->GetAll('SELECT DISTINCT flag FROM domains_flags WHERE domainid = ?', array($domain->ID));
$flag_list = array();
foreach ($flags_data as $flag_row) {
$flag_list[] = $flag_row['flag'];
}
$domain->SetFlagList($flag_list);
// Load contacts
foreach ($this->ContactFieldTypeMap as $field => $contact_type) {
$CLID = $row[$field];
if ($CLID) {
try {
$contact = $this->DBContact->LoadByCLID($CLID, $registry_manifest);
} catch (Exception $e) {
$contact = $registry->NewContactInstance($contact_type);
$contact->CLID = $CLID;
}
$domain->SetContact($contact, $contact_type);
}
}
// Add pending operations to domain
$operations = $this->DB->Execute("SELECT * FROM pending_operations WHERE objecttype='DOMAIN' AND objectid=?", array($domain->ID));
while ($op = $operations->FetchRow()) {
if ($op) {
$domain->AddPendingOperation($op["operation"]);
}
}
// Add domain to loaded objects storage
$this->LoadedObjects[$domain->ID] = clone $domain;
return $domain;
}
function setUp ()
{
$Factory = RegistryModuleFactory::GetInstance();
$this->Registry = $Factory->GetRegistryByExtension("tel");
/*
old stuff for ote
// User input and initialized by EPP-DRS in real test
$TestConf = DotTELRegistryModule::GetTestConfigurationForm();
$test_conf = $TestConf->ListFields();
$test_conf['ServerHost']->Value = 'web3.hostdad.com';
$test_conf['ServerPort']->Value = '707';
$test_conf['Login-1']->Value = 'NDN29Y';
$test_conf['Password-1']->Value = 'AwTkQy';
$test_conf['Login-2']->Value = 'NDN29Y2';
$test_conf['Password-2']->Value = 'AwTkQy';
$test_conf['SSLCertPath']->Value = '/home/marat/cert/tel-certchain.pem';
$test_conf['SSLCertPass']->Value = '';
//
// Initialize registry
$ModuleConf = DotTELRegistryModule::GetConfigurationForm();
$module_conf = $ModuleConf->ListFields();
$module_conf['ServerHost']->Value = $test_conf['ServerHost']->Value;
$module_conf['ServerPort']->Value = $test_conf['ServerPort']->Value;
$module_conf['Login']->Value = $test_conf['Login-1']->Value;
$module_conf['Password']->Value = $test_conf['Password-1']->Value;
$module_conf['SSLCertPath']->Value = $test_conf['SSLCertPath']->Value;
$module_conf['SSLCertPass']->Value = $test_conf['SSLCertPass']->Value;
$ModuleConf2 = DotTELRegistryModule::GetConfigurationForm();
$module_conf2 = $ModuleConf2->ListFields();
$module_conf2['ServerHost']->Value = $test_conf['ServerHost']->Value;
$module_conf2['ServerPort']->Value = $test_conf['ServerPort']->Value;
$module_conf2['Login']->Value = $test_conf['Login-2']->Value;
$module_conf2['Password']->Value = $test_conf['Password-2']->Value;
$module_conf2['SSLCertPath']->Value = $test_conf['SSLCertPath']->Value;
$module_conf2['SSLCertPass']->Value = $test_conf['SSLCertPass']->Value;
$this->Module = new DotTELRegistryModule();
$this->Module2 = new DotTELRegistryModule();
$this->Module->InitializeModule("tel", $ModuleConf);
$this->Module2->InitializeModule("tel", $ModuleConf2);
$this->Registry = new Registry($this->Module);
$this->Registry2 = new Registry($this->Module2);
$this->module_conf = $module_conf;
$this->module_conf2 = $module_conf2;
// Read test preferences
$prefs = parse_ini_file(MODULES_PATH . '/registries/DotTEL/testprefs');
$prefs['num']++;
$this->Prefix = "absdef" . sprintf('%02d', $prefs['num']);
// Save prefs to the next run
$prefs_file = '';
foreach ($prefs as $k => $v)
{
$prefs_file .= "{$k}={$v}\n";
}
file_put_contents(MODULES_PATH . '/registries/DotTEL/testprefs', $prefs_file);
*/
}
function setUp()
{
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension('eu');
$this->contact_data = array("name" => "Marat Komarov", "org" => "Webta", "street1" => "Testing str. 80", "street2" => "Drive 54", "city" => "Testing", "pc" => "3129112", "cc" => "GB", "sp" => "test", "voice" => "+333-432-1234567", "fax" => "+333-432-1234567", "email" => "*****@*****.**", "lang" => "fr");
}
public function OnPaid(Invoice $Invoice, AbstractPaymentModule $payment_module = null)
{
$db = Core::GetDBInstance();
if (!in_array($Invoice->Purpose, $this->HandledPurposes)) {
return;
}
Log::Log("RegistryInvoiceObserver::OnPaid(InvoiceID={$Invoice->ID})", E_USER_NOTICE);
// Get domain information
try {
$Domain = DBDomain::GetInstance()->Load($Invoice->ItemID);
} catch (Exception $e) {
Log::Log("RegistryInvoiceObserver::OnPaid() thown exception: {$e->getMessage()}", E_USER_ERROR);
}
if ($Domain) {
Log::Log("Invoice purpose: {$Invoice->Purpose}", E_USER_NOTICE);
// Get user information
$userinfo = $db->GetRow("SELECT * FROM users WHERE id=?", array($Domain->UserID));
// Check command
switch ($Invoice->Purpose) {
case INVOICE_PURPOSE::DOMAIN_TRADE:
try {
$Action = new UpdateDomainContactAction($Invoice);
try {
$Action->Run();
} catch (UpdateDomainContactAction_Exception $e) {
Log::Log(sprintf("Trade failed. %s", $e->getMessage()), E_ERROR);
DBDomain::GetInstance()->Save($Action->GetDomain());
// Send mail
$args = array("client" => $userinfo, "Invoice" => $Invoice, "domain_name" => $Domain->Name, "extension" => $Domain->Extension, "domain_trade_failure_reason" => $e->getMessage());
mailer_send("domain_trade_action_required.eml", $args, $userinfo["email"], $userinfo["name"]);
}
} catch (LogicException $e2) {
Log::Log($e2->getMessage(), E_ERROR);
}
break;
case INVOICE_PURPOSE::DOMAIN_CREATE:
if ($Domain->Status == DOMAIN_STATUS::AWAITING_PAYMENT || $Domain->Status == DOMAIN_STATUS::REJECTED) {
$Domain->Status = DOMAIN_STATUS::PENDING;
$Domain->IncompleteOrderOperation = INCOMPLETE_OPERATION::DOMAIN_CREATE;
$Domain = DBDomain::GetInstance()->Save($Domain);
// If domain has incomplete information skip domain creation. Update status to Pending.
if (count($Domain->GetContactList()) == 0 || count($Domain->GetNameserverList()) == 0) {
//
// Send mail
//
Log::Log("Domain registration process not completed. Need more information from client.", E_USER_NOTICE);
$args = array("client" => $userinfo, "Invoice" => $Invoice, "domain_name" => $Domain->Name, "extension" => $Domain->Extension);
mailer_send("domain_registration_action_required.eml", $args, $userinfo["email"], $userinfo["name"]);
// Write information in invoice
$Invoice->ActionStatus = INVOICE_ACTION_STATUS::FAILED;
$Invoice->ActionFailReason = _('Domain registration process not completed. Need more information from client.');
} else {
Log::Log("Trying to register domain", E_USER_NOTICE);
///// get Registry instance and connect to registry server
try {
$Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($Domain->Extension);
} catch (Exception $e) {
Log::Log($e->getMessage(), E_ERROR);
return;
}
// Validate license for this module
if (!License::IsModuleLicensed($Registry->GetModuleName())) {
throw new LicensingException("Your license does not permit module {$Registry->ModuleName()}");
}
//
$extra_data = $db->GetAll("SELECT * FROM domains_data WHERE domainid=?", array($Domain->ID));
if ($extra_data && count($extra_data) > 0) {
foreach ($extra_data as $v) {
$extra[$v["key"]] = $v["value"];
}
} else {
$extra = array();
}
// Try to create domain name
try {
$cr = $Registry->CreateDomain($Domain, $Domain->Period, $extra);
} catch (Exception $e) {
$args = array("client" => $userinfo, "Invoice" => $Invoice, "domain_name" => $Domain->Name, "extension" => $Domain->Extension, "domain_reg_failure_reason" => $e->getMessage());
mailer_send("domain_registration_action_required.eml", $args, $userinfo["email"], $userinfo["name"]);
// If domain not created
Log::Log("Cannot register domain name. Server return: " . $e->getMessage(), E_ERROR);
$Invoice->ActionStatus = INVOICE_ACTION_STATUS::FAILED;
$Invoice->ActionFailReason = $e->getMessage();
}
if ($cr) {
// If domain created
Log::Log(sprintf("Domain %s successfully registered. Updating database", $Domain->GetHostName()), E_USER_NOTICE);
$Invoice->ActionStatus = INVOICE_ACTION_STATUS::COMPLETE;
}
}
} else {
Log::Log("Domain status '{$Domain->Status}'. Expected 'Awaiting payment'", E_ERROR);
$retval = false;
$Invoice->ActionStatus = INVOICE_ACTION_STATUS::FAILED;
$Invoice->ActionFailReason = sprintf(_("Domain status '%s'. Expected 'Awaiting payment'"), $Domain->Status);
}
break;
case INVOICE_PURPOSE::DOMAIN_TRANSFER:
if ($Domain->Status == DOMAIN_STATUS::AWAITING_PAYMENT) {
//
// Send mail
//
$args = array("client" => $userinfo, "domain_name" => $Domain->Name, "extension" => $Domain->Extension, "Invoice" => $Invoice);
mailer_send("domain_transfer_action_required.eml", $args, $userinfo["email"], $userinfo["name"]);
Log::Log("Domain transfer process not completed. Need more information from client.", E_USER_NOTICE);
$Domain->IncompleteOrderOperation = INCOMPLETE_OPERATION::DOMAIN_TRANSFER;
$Domain->Status = DOMAIN_STATUS::PENDING;
DBDomain::GetInstance()->Save($Domain);
$Invoice->ActionStatus = INVOICE_ACTION_STATUS::COMPLETE;
}
break;
case INVOICE_PURPOSE::DOMAIN_RENEW:
// Renew domain name
Log::Log("Trying to renew domain", E_USER_NOTICE);
///// Get registry instance and connect to registry server
try {
$Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($Domain->Extension);
} catch (Exception $e) {
Log::Log($e->getMessage(), E_ERROR);
return;
}
try {
$renew = $Registry->RenewDomain($Domain, array('period' => $Domain->Period));
} catch (Exception $e) {
$renew = false;
$err = $e->getMessage();
}
if ($renew) {
Log::Log("Domain successfully renewed.", E_USER_NOTICE);
$Invoice->ActionStatus = INVOICE_ACTION_STATUS::COMPLETE;
$Domain->DeleteStatus = DOMAIN_DELETE_STATUS::NOT_SET;
DBDomain::GetInstance()->Save($Domain);
} else {
$Domain->SetExtraField('RenewInvoiceID', $Invoice->ID);
DBDomain::GetInstance()->Save($Domain);
//
// Send mail here
//
$args = array("client" => $userinfo, "domain_name" => $Domain->Name, "extension" => $Domain->Extension, "reason" => $err, "years" => $Domain->Period);
mailer_send("renewal_failed.eml", $args, $userinfo["email"], $userinfo["name"]);
// If renew failed
Log::Log("Cannot renew domain name. Server return: " . $err, E_ERROR);
$Invoice->ActionStatus = INVOICE_ACTION_STATUS::FAILED;
$Invoice->ActionFailReason = $err;
}
/////
break;
}
$Invoice->Save();
} else {
// Domain not found
Log::Log(sprintf("Domain width ID '%s' not found.", $Invoice->ItemID), E_ERROR);
}
// OnPaymentComplete routine succeffully completed.
Log::Log("RegistryInvoiceObserver::OnPaid Successfully completed.", E_USER_NOTICE);
}
public function OnStartForking()
{
global $TLDs, $modules_config;
Log::Log("Starting 'Renew' cronjob...", E_USER_NOTICE);
$db = Core::GetDBInstance();
$RegFactory = RegistryModuleFactory::GetInstance();
$DbDomain = DBDomain::GetInstance();
$this->ThreadArgs = array();
// For each client send notice about expiring domains
$sql = "SELECT id FROM users";
foreach ($db->GetAll($sql) as $client_data)
{
try
{
$Client = Client::Load($client_data["id"]);
$sql = "
SELECT
d.id, d.name, d.TLD, d.end_date,
IF(dd.`key` IS NOT NULL, FROM_UNIXTIME(dd.`value`), DATE_SUB(end_date, INTERVAL 1 DAY)) AS last_renew_date
FROM domains d
LEFT JOIN domains_data dd ON (dd.domainid = d.id AND dd.`key` = 'RenewalDate')
WHERE d.status = '".DOMAIN_STATUS::DELEGATED."' AND d.userid = ? AND (TO_DAYS(end_date) - TO_DAYS(NOW()) BETWEEN 0 AND ?) AND renew_disabled != 1
ORDER BY d.end_date ASC";
$start_days = $Client->GetSettingValue(ClientSettings::EXPIRE_NOTIFY_START_DAYS);
$domains_data = $db->GetAll($sql, array($Client->ID, $start_days ? $start_days : 60));
// Send email to client
if ($domains_data)
{
$eml_args = array(
"client_name" => $Client->Name,
"domains" => array()
);
foreach ($domains_data as $domain_data)
{
$eml_args["domains"][] = array(
"name" => "{$domain_data["name"]}.{$domain_data["TLD"]}",
"expire_date" => date("Y-m-d", strtotime($domain_data["end_date"])),
"last_renew_date" => date("Y-m-d", strtotime($domain_data["last_renew_date"]))
);
}
mailer_send("bulk_renew_notice.eml", $eml_args, $Client->Email, $Client->Name);
}
foreach ($domains_data as $domain_data)
{
$Domain = $DbDomain->Load($domain_data['id']);
// Find more then 60 days invoice
// Legacy from old notification system.
// FIXME: Need to create a better solution to finding unpaid invoices for upgoing renew
$dtNearest = date("Y-m-d", $Domain->ExpireDate - 60*24*60*60);
$invoiceid = $db->GetOne("SELECT id FROM invoices
WHERE userid=? AND itemid=? AND purpose=? AND dtcreated >= ?",
array($Domain->UserID, $Domain->ID, INVOICE_PURPOSE::DOMAIN_RENEW, $dtNearest)
);
// Generate invoice
if (!$invoiceid && !$Domain->RenewDisabled)
{
$Registry = $RegFactory->GetRegistryByExtension($Domain->Extension);
$config = $Registry->GetManifest()->GetSectionConfig();
$period = (int)$config->domain->renewal->min_period;
$Domain->Period = $period;
$DbDomain->Save($Domain);
try
{
$Invoice = new Invoice(INVOICE_PURPOSE::DOMAIN_RENEW, $Domain->ID, $Domain->UserID);
$Invoice->Description = sprintf(_("%s domain name renewal for %s years"), $Domain->GetHostName(), $period);
$Invoice->Cancellable = 1;
$Invoice->Save();
if ($Invoice->Status == INVOICE_STATUS::PENDING)
{
$diff_days = ceil(($Domain->ExpireDate - time())/(60*60*24));
Application::FireEvent('DomainAboutToExpire', $Domain, $diff_days);
}
}
catch(Exception $e)
{
Log::Log("Cannot create renew invoice. Caught: {$e->getMessage()}", E_USER_ERROR);
}
}
}
}
catch (Exception $e)
{
Log::Log("Caught: {$e->getMessage()}", E_USER_ERROR);
}
}
/*
$supported_extensions = $RegFactory->GetExtensionList();
// For all supported TLDs
foreach ($supported_extensions as $ext)
{
$Registry = $RegFactory->GetRegistryByExtension($ext);
$config = $Registry->GetManifest()->GetSectionConfig();
$days = $config->domain->renewal->notifications->period;
$biggest_period = (int)$days[0];
// For each notification
foreach($days as $expireDays)
{
$expireDays = (int)$expireDays;
$domains = $db->GetAll("
SELECT dom.* FROM domains AS dom
LEFT JOIN domains_data AS ext
ON dom.id = ext.domainid AND ext.`key` = 'RenewalDate'
WHERE dom.TLD = ?
AND dom.status = ?
AND TO_DAYS(IF
(
ext.`key` IS NOT NULL AND TO_DAYS(FROM_UNIXTIME(ext.`value`)) < TO_DAYS(dom.end_date),
FROM_UNIXTIME(ext.`value`),
dom.end_date
)) - TO_DAYS(NOW()) = ?
", array(
$ext, DOMAIN_STATUS::DELEGATED, $expireDays
));
// For each domain
foreach($domains as $domain_info)
{
try
{
$Domain = DBDomain::GetInstance()->Load($domain_info['id']);
$dtNearest = date("Y-m-d", strtotime($domain_info["end_date"]) - $biggest_period*24*60*60);
$invoiceid = $db->GetOne("SELECT id FROM invoices
WHERE userid=? AND itemid=? AND purpose=? AND status=? AND dtcreated >= ?",
array($Domain->UserID, $Domain->ID, INVOICE_PURPOSE::DOMAIN_RENEW, INVOICE_STATUS::PENDING, $dtNearest)
);
// Generate invoice
if (!$invoiceid && !$Domain->RenewDisabled)
{
$period = (int)$config->domain->renewal->min_period;
$Domain->Period = $period;
DBDomain::GetInstance()->Save($Domain);
try
{
$Invoice = new Invoice(INVOICE_PURPOSE::DOMAIN_RENEW, $Domain->ID, $Domain->UserID);
$Invoice->Description = sprintf(_("%s domain name renewal for %s years"), $Domain->GetHostName(), $period);
$Invoice->Cancellable = 1;
$Invoice->Save();
if ($Invoice->Status == INVOICE_STATUS::PENDING)
{
$userinfo = $db->GetRow("SELECT * FROM users WHERE id=?", array($Domain->UserID));
//print "send notification and invoice about {$Domain->GetHostName()} to {$userinfo['email']}\n";
$args = array(
"domain_name" => $Domain->Name,
"extension" => $Domain->Extension,
"invoice" => $Invoice,
"expDays" => $expireDays,
"client" => $userinfo,
"renewal_date" => $Domain->RenewalDate
);
mailer_send("renew_notice.eml", $args, $userinfo["email"], $userinfo["name"]);
Application::FireEvent('DomainAboutToExpire', $Domain, $expireDays);
}
}
catch(Exception $e)
{
$errmsg = $e->getMessage();
}
}
else
{
$userinfo = $db->GetRow("SELECT * FROM users WHERE id=?", array($Domain->UserID));
//print "send notification about {$Domain->GetHostName()} to {$userinfo['email']}\n";
$args = array(
"domain_name" => $Domain->Name,
"extension" => $Domain->Extension,
"expDays" => $expireDays,
'client' => $userinfo,
"renewal_date" => $Domain->RenewalDate
);
mailer_send("renew_notice.eml", $args, $userinfo["email"], $userinfo["name"]);
}
}
catch (Exception $e)
{
Log::Log("First domains loop. Caught: ".$e->getMessage(), E_USER_ERROR);
}
}
}
}
*/
// For auto-renew registries the day before expiration date
// send to unpaid domains delete command and mark them as expired
Log::Log("Going to process expiring tomorrow domains in 'auto-renew' registries", E_USER_NOTICE);
$days_before = 1;
$del_date = strtotime("+$days_before day");
$delete_report = array();
$domains = $db->GetAll("SELECT dom.id, dom.name, dom.TLD FROM domains AS dom
LEFT JOIN domains_data AS ext ON dom.id = ext.domainid AND ext.`key` = 'RenewalDate'
LEFT JOIN invoices AS i ON (dom.id = i.itemid AND i.purpose = 'Domain_Renew')
WHERE dom.status = ?
AND TO_DAYS(IF
(
ext.`key` IS NOT NULL AND TO_DAYS(FROM_UNIXTIME(ext.`value`)) < TO_DAYS(dom.end_date),
FROM_UNIXTIME(ext.`value`),
dom.end_date
)) - TO_DAYS(NOW()) = ? AND ((i.status = ? AND TO_DAYS(NOW()) - TO_DAYS(i.dtcreated) <= 60) OR i.status IS NULL)",
array(DOMAIN_STATUS::DELEGATED, $days_before, INVOICE_STATUS::PENDING));
foreach ($domains as $domain_info)
{
try
{
$Domain = $DbDomain->Load($domain_info["id"]);
$Registry = $RegFactory->GetRegistryByExtension($domain_info["TLD"]);
$RegistryOptions = $Registry->GetManifest()->GetRegistryOptions();
$auto_renewal = (int)$RegistryOptions->ability->auto_renewal;
$scheduled_delete = (int)$RegistryOptions->ability->scheduled_delete;
if ($auto_renewal)
{
if (CONFIG::$AUTO_DELETE)
{
try
{
// For 'auto-renew + scheduled delete' send scheduled delete
if ($scheduled_delete)
{
Log::Log(sprintf("Send scheduled delete to domain '%s' at '%s'",
$Domain->GetHostName(), date("Y-m-d", $del_date)), E_USER_NOTICE);
$Registry->DeleteDomain($Domain, $del_date);
}
// For 'auto-renew' only send direct delete
else
{
Log::Log(sprintf("Send direct delete to domain '%s'",
$Domain->GetHostName()), E_USER_NOTICE);
$Registry->DeleteDomain($Domain);
}
$this->MarkAsExpired($Domain);
}
catch (Exception $e)
{
Log::Log(sprintf("Cannot delete expiring domain '%s'. %s",
$Domain->GetHostName(), $e->getMessage()), E_USER_ERROR);
}
}
else
{
Log::Log(sprintf("Domain %s need to be deleted. Send it to admin court",
$Domain->GetHostName()), E_USER_NOTICE);
// Send to the administrator court
$db->Execute("UPDATE domains SET delete_status = ? WHERE id = ?",
array(DOMAIN_DELETE_STATUS::AWAIT, $Domain->ID));
$userinfo = $db->GetRow("SELECT * FROM users WHERE id = ?", array($Domain->UserID));
$delete_report[] = array
(
"domain" => $Domain->GetHostName(),
"user" => "{$userinfo["name"]}({$userinfo["email"]})"
);
}
}
}
catch (Exception $e)
{
Log::Log(sprintf("Cannot load expiring domain '%s'. %s",
"{$domain_info["name"]}.{$domain_info["TLD"]}", $e->getMessage()), E_USER_ERROR);
}
}
// Notify admin about expiring domains need to be deleted
if ($delete_report)
{
$args = array(
"date" => date("Y-m-d", $del_date),
"report" => $delete_report,
"confirm_url" => CONFIG::$SITE_URL . "/admin/domains_await_delete_confirmation.php"
);
mailer_send("root_domains_await_delete.eml", $args, CONFIG::$EMAIL_ADMIN, CONFIG::$EMAIL_ADMINNAME);
}
// For all registries mark domain as expired at expiration date
Log::Log("Going to process expiring today domains", E_USER_NOTICE);
$domains = $db->GetAll("SELECT id, name, TLD FROM domains
WHERE TO_DAYS(end_date) = TO_DAYS(NOW()) AND status = ? AND delete_status != ?",
array(DOMAIN_STATUS::DELEGATED, DOMAIN_DELETE_STATUS::AWAIT));
foreach ($domains as $domain_info)
{
try
{
$Domain = $DbDomain->Load($domain_info["id"]);
$this->MarkAsExpired($Domain);
}
catch (Exception $e)
{
Log::Log(sprintf("Cannot load expired domain '%s'. %s",
"{$domain_info["name"]}.{$domain_info["TLD"]}", $e->getMessage()), E_USER_ERROR);
}
}
// Cleanup database from expired and transferred domains (more then 60 days)
Log::Log("Going to cleanup database from transferred and expired domains (more then 60 days)", E_USER_NOTICE);
$domains = $db->GetAll("
SELECT * FROM domains
WHERE (status=? OR status=?) AND
((TO_DAYS(NOW()-TO_DAYS(end_date)) >= 60) OR (TO_DAYS(NOW()-TO_DAYS(dtTransfer)) >= 60))",
array(DOMAIN_STATUS::TRANSFERRED, DOMAIN_STATUS::EXPIRED));
foreach ($domains as $domain_info)
{
try
{
Log::Log("Delete {$domain_info["name"]}.{$domain_info["TLD"]} from database. "
. "(start_date={$domain_info["start_date"]}, end_date={$domain_info["end_date"]}, status={$domain_info["status"]})",
E_USER_NOTICE);
$Domain = $DbDomain->Load($domain_info['id']);
$DbDomain->Delete($Domain);
}
catch (Exception $ignore)
{
Log::Log("Catch ignored exception. {$ignore->getMessage()}", E_USER_NOTICE);
}
}
// Notify customers about low balance
Log::Log("Going to notify customers about their low balance", E_USER_NOTICE);
$user_ids = $db->GetAll("SELECT userid FROM user_settings
WHERE `key` = '".ClientSettings::LOW_BALANCE_NOTIFY."' AND `value` = '1'");
foreach ($user_ids as $id)
{
try
{
$id = $id["userid"];
$Client = Client::Load($id);
$amount = (float)$db->GetOne("SELECT `total` FROM balance WHERE clientid = ?", array($id));
$min_amount = (float)$Client->GetSettingValue(ClientSettings::LOW_BALANCE_VALUE);
if ($amount < $min_amount)
{
mailer_send("low_balance_notice.eml", array(
"client" => array("name" => $Client->Name),
"amount" => number_format($min_amount, 2),
"currency" => CONFIG::$CURRENCYISO
), $Client->Email, $Client->Name);
}
}
catch (Exception $e)
{
Log::Log("Cannot notify customer about his low balance. Error: {$e->getMessage()}", E_USER_ERROR);
}
}
}
function Handle(Task $Task)
{
$Job = $Task->JobObject;
Log::Log("This is job: " . var_export($Job, true), E_USER_NOTICE);
$Order = new Order($Task->userid);
foreach ($Job->tlds as $tld) {
// Get all domains of $tld
$targets = $this->GetTargetsForTld($Task->GetActiveTargets(), $tld);
Log::Log("{$tld} has " . count($targets) . " targets", E_USER_NOTICE);
$RegAction = null;
try {
Log::Log("Init {$tld} registry");
$Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($tld);
Log::Log("Init {$tld} reg action");
$RegAction = new RegisterDomainAction(array('tld' => $tld, 'Registry' => $Registry, 'Order' => $Order, 'clid_list' => $Job->contact_list[$tld], 'ns_list' => $Job->ns_list, 'managed_dns_enabled' => false, 'extra_data' => $Job->extra[$tld]));
} catch (RegisterDomainAction_Exception $e) {
$msg = $e->getMessage();
if ($e->ErrorList) {
$msg .= ". " . join(" ", $e->ErrorList->GetAllMessages());
}
Log::Log(sprintf("Failed to init RegisterDomainAction. %s. File:%s Line:%s \n%s", $msg, $e->getFile(), $e->getLine(), $e->getTraceAsString()), E_USER_NOTICE);
foreach ($targets as $Target) {
$Target->fail_reason = "RegisterDomainAction initialization failed. {$msg}";
$Task->TargetFailed($Target);
}
continue;
}
// Register each domain
foreach ($targets as $Target) {
try {
list($domain_name, ) = explode(".", $Target->target, 2);
$Domain = $Registry->NewDomainInstance();
$Domain->Name = $domain_name;
$Domain->Period = $Job->periods[$tld];
$Domain->UserID = $Task->userid;
Log::Log("Register {$Domain->GetHostName()}", E_USER_NOTICE);
$result = $RegAction->Run($Domain);
$Target->action_result = $result;
$Task->TargetCompleted($Target);
} catch (RegisterDomainAction_Exception $e) {
$msg = $e->getMessage();
if ($e->ErrorList) {
$msg .= ". " . join(" ", $e->ErrorList->GetAllMessages());
}
Log::Log(sprintf("Registration failed for %s. %s. File:%s Line:%s \n%s", $Domain->GetHostName(), $msg, $e->getFile(), $e->getLine(), $e->getTraceAsString()), E_USER_NOTICE);
$Target->fail_reason = $msg;
$Task->TargetFailed($Target);
}
}
}
Log::Log("Order has " . count($Order->GetInvoiceList()) . " invoices", E_USER_NOTICE);
$Order->Save();
}
/**
* Executor
*
* @throws UpdateDomainContactTask_Exception
*/
public function Run($userid = null)
{
try {
$Factory = RegistryModuleFactory::GetInstance();
$Registry = $Factory->GetRegistryByExtension($this->Domain->Extension);
$Manifest = $Registry->GetManifest();
if ($userid && $this->Domain->UserID != $userid) {
throw new UpdateDomainContactAction_Exception(_("You don't have permissions for manage this domain"), UpdateDomainContactAction_Exception::DOMAIN_NOT_BELONGS_TO_USER);
}
$OldContact = $this->Domain->GetContact($this->contact_type);
if ($this->NewContact && $this->NewContact->UserID != $this->Domain->UserID) {
throw new UpdateDomainContactAction_Exception(_("You don't have permissions for using this contact"), UpdateDomainContactAction_Exception::CONTACT_NOT_BELONGS_TO_USER);
}
$trade = $Manifest->GetRegistryOptions()->ability->trade == '1';
if ($this->contact_type != CONTACT_TYPE::REGISTRANT || !$trade) {
try {
$Registry->UpdateDomainContact($this->Domain, $this->contact_type, $OldContact, $this->NewContact);
return $this->Domain->HasPendingOperation(Registry::OP_UPDATE) ? UpdateDomainContactAction_Result::PENDING : UpdateDomainContactAction_Result::OK;
} catch (Exception $e) {
throw new UpdateDomainContactAction_Exception(sprintf(_("Cannot change contact. Reason: %s"), $e->getMessage()));
}
} else {
// Execute trade when:
// - Trade invoice is paid
// - Previous trade failed
if ($this->Domain->IncompleteOrderOperation == INCOMPLETE_OPERATION::DOMAIN_TRADE || $this->Invoice && $this->Invoice->Status == INVOICE_STATUS::PAID) {
$this->Domain->SetContact($this->NewContact, CONTACT_TYPE::REGISTRANT);
$this->Domain->IncompleteOrderOperation = null;
$extra["requesttype"] = "ownerChange";
try {
$trade = $Registry->ChangeDomainOwner($this->Domain, 1, $extra);
return $this->Domain->HasPendingOperation(Registry::OP_TRADE) ? UpdateDomainContactAction_Result::PENDING : UpdateDomainContactAction_Result::OK;
} catch (Exception $e) {
$this->Domain->IncompleteOrderOperation = INCOMPLETE_OPERATION::DOMAIN_TRADE;
if ($this->Invoice) {
$this->Invoice->ActionStatus = INVOICE_ACTION_STATUS::FAILED;
$this->Invoice->ActionFailReason = $e->getMessage();
}
throw new UpdateDomainContactAction_Exception(sprintf(_("Cannot change contact. Reason: %s"), $e->getMessage()));
}
} else {
// Issue an invoice for trade operation
$invoiceid = $this->Db->GetOne("SELECT * FROM invoices WHERE status=? AND itemid=? AND purpose=?", array(INVOICE_STATUS::PENDING, $this->Domain->ID, INVOICE_PURPOSE::DOMAIN_TRADE));
if (!$invoiceid) {
$this->Domain->SetExtraField("NewRegistrantCLID", $this->NewContact->CLID);
DBDomain::GetInstance()->Save($this->Domain);
$Invoice = new Invoice(INVOICE_PURPOSE::DOMAIN_TRADE, $this->Domain->ID, $userid);
$Invoice->Description = sprintf(_("%s domain name trade"), $this->Domain->GetHostName());
$Invoice->Save();
$this->Invoice = $Invoice;
return UpdateDomainContactAction_Result::INVOICE_GENERATED;
} else {
throw new UpdateDomainContactAction_Exception(_("Another domain trade is already initiated"));
}
}
}
} catch (Exception $e) {
throw new UpdateDomainContactAction_Exception($e->getMessage());
}
}
function setUp()
{
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension('in.na');
$this->contact_fields = array('name' => 'Marat Komarov', 'email' => '*****@*****.**', 'street1' => 'Test street', 'city' => 'Sebastopol', 'pc' => '99011', 'sp' => 'Crimea', 'cc' => 'UA', 'voice' => '+380-434-4343223', 'fax' => '+380-424-5546433');
}
$Validator = new Validator();
$lines = explode("\n", $post_domains);
$post_domainname = FQDN::Sanitize($post_domainname);
list($domain_name, $extension) = FQDN::Parse($post_domainname);
$expiredate = trim($post_dt);
// Validate date. Sucks.
if (!preg_match("/^[0-9]{4}-[0-9]{2}-[0-9]{2}\$/", $expiredate) || !strtotime($expiredate)) {
throw new ApplicationException(sprintf(_("Incorrect expiration date.")));
}
// Validate domain name
if (!$Validator->IsDomain($post_domainname)) {
throw new Exception(sprintf(_("Incorrect domain name: %s"), $post_domainname));
}
if (!$Registries[$extension]) {
try {
$Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($extension);
} catch (Exception $e) {
throw new ApplicationException($e->getMessage());
}
$Manifest = $Registry->GetManifest();
if ($Manifest->GetRegistryOptions()->ability->preregistration != 1) {
throw new ApplicationException(sprintf(_("Module %s does not support domain pre-registration."), $Registry->GetModuleName()));
}
}
$Domain = $Registry->NewDomainInstance();
$Domain->Name = $domain_name;
$Domain->UserID = $_SESSION['userid'];
try {
$res = $Registry->DomainCanBeRegistered($Domain)->Result;
} catch (Exception $e) {
throw new ApplicationException(sprintf(_("Cannot check availability of %s. %s")));
function __construct()
{
parent::__construct();
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByName('EPPNL');
}
function __construct()
{
$registry = RegistryModuleFactory::GetInstance()->GetRegistryByName('DotNL');
$registrantConfig = $registry->GetManifest()->GetContactConfigByGroup('registrant');
$legalFormField = $registrantConfig->xpath('descendant::field[@name="legal-form"]');
if (!count($legalFormField)) {
throw new Exception("Cannot find 'legal-form' field in DotNL manifest");
}
$this->legalFormField = $legalFormField[0];
}
for ($i = 1; $i < $_SERVER["argc"]; $i++) {
list($name, $tld) = explode(".", $_SERVER["argv"][$i], 2);
$rows[] = array("name" => $name, "TLD" => $tld);
}
}
} else {
print "Usage sync.php [options] [domain1, domain2 ...]\n";
print "Options:\n";
print " --all Sync all 'Delegated' domains\n";
die;
}
print "Starting...\n";
foreach ($rows as $row) {
try {
print "Syncing {$row["name"]}.{$row["TLD"]}";
$Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($row["TLD"]);
$Domain = DBDomain::GetInstance()->LoadByName($row["name"], $row["TLD"]);
$Domain = $Registry->GetRemoteDomain($Domain);
if ($Domain->RemoteCLID && $Domain->RemoteCLID != $Registry->GetRegistrarID()) {
$Domain->Status = DOMAIN_STATUS::TRANSFERRED;
}
DBDomain::GetInstance()->Save($Domain);
print " OK\n";
sleep(2);
} catch (Exception $e) {
/*
if ($e instanceof ObjectNotExistsException)
{
Log::Log("Delete domain {$Domain->GetHostName()}", E_USER_NOTICE);
print " Deleted\n";
DBDomain::GetInstance()->Delete($Domain);
function __construct()
{
$this->db = Core::GetDBInstance();
$this->registry_factory = RegistryModuleFactory::GetInstance();
}
function setUp()
{
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension("se");
}
function setUp()
{
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension("net.mx");
$this->Module = $this->Registry->GetModule();
}
public function OnStartForking()
{
Log::Log("Starting 'PreregistrationUpdate' cronjob...", E_USER_NOTICE);
$db = Core::GetDBInstance();
$this->ThreadArgs = array();
//
// Update registered domains
//
$domains = $db->Execute("SELECT * FROM domains WHERE status=?", array(DOMAIN_STATUS::PREREGISTRATION_DELEGATED));
while ($domain = $domains->FetchRow())
{
////
try
{
$Domain = DBDomain::GetInstance()->Load($domain['id']);
}
catch(Exception $e)
{
Log::Log(__CLASS__.": thrown exception: '{$e->getMessage()}' File: {$e->getFile()}:{$e->getLine()}", E_ERROR);
exit();
}
if ($Domain->Status == DOMAIN_STATUS::AWAITING_PREREGISTRATION)
{
try
{
$Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension($Domain->Extension);
}
catch(Exception $e)
{
Log::Log(__CLASS__.": thrown exception: '{$e->getMessage()}' File: {$e->getFile()}:{$e->getLine()}", E_ERROR);
exit();
}
try
{
$Domain = $Registry->GetRemoteDomain($Domain);
}
catch(Exception $e)
{
Log::Log(__CLASS__.": Cannot get remote domain: '{$e->getMessage()}' File: {$e->getFile()}:{$e->getLine()}", E_ERROR);
exit();
}
if (($Domain->RemoteCLID == $Registry->GetRegistrarID()))
{
$Domain->Status = DOMAIN_STATUS::DELEGATED;
DBDomain::GetInstance()->Save($Domain);
}
else
{
Log::Log(__CLASS__.": Remote domain not owned by us. Domain RegistrarID: {$Domain->RemoteCLID}", E_ERROR);
exit();
}
}
///
}
//
// Update failed domains
//
$domains = $db->Execute("SELECT * FROM domains WHERE status=? AND TO_DAYS(NOW()) > TO_DAYS(start_date)", array(DOMAIN_STATUS::AWAITING_PREREGISTRATION));
while($domain = $domains->FetchRow())
$db->Execute("UPDATE domains SET status=? WHERE id=?", array(DOMAIN_STATUS::REGISTRATION_FAILED, $domain['id']));
}
function setUp()
{
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension("eu");
//$eu_transport = $this->Registry->GetModule()->GetTransport();
//$mock_transport = new DotEUMockupTransportBug358();
$this->Registry->GetModule()->SetTransport(new DotEUMockupTransportBug358());
}
function setUp ()
{
$this->Registry = RegistryModuleFactory::GetInstance()->GetRegistryByExtension("gr");
$this->DBDomain = DBDomain::GetInstance();
}
