src/Controller/HostingController.php line 307

Open in your IDE?
  1. <?php
  2. // src/Controller/EntrepriseController.php
  3. namespace App\Controller;
  5. use Symfony\Component\HttpFoundation\Response;
  6. use Symfony\Component\Routing\Annotation\Route;
  7. use Symfony\Component\HttpFoundation\Session\SessionInterface;
  8. use Symfony\Component\HttpFoundation\Request;
  9. use Symfony\Component\HttpFoundation\JsonResponse;
  10. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  12. /**
  13.  * @Route("/{_locale}/hosting")
  14.  */
  16. class HostingController extends AbstractController
  17. {    
  18.     private $session;
  19.     
  20.     public function __construct(SessionInterface $session)
  21.     {
  22.         $this->session = $session;
  23.     }
  24.     
  25.     /**
  26.      * @Route("/check-domain", name="check_domain")
  27.      */
  28.     public function checkDomainAction(Request $request)
  29.     {
  30.         $tlds = array('com', 'net', 'online', 'org', 'store', 'site', 'tech', 'xyz',
  31.         'biz', 'fun', 'info', 'pro', 'fr', 'be', 'eu');
  32.         $requestResults = array(
  33.             'data' => array(),
  34.             'ok' => ''
  35.         );
  36.         $results = array();
  37.         $domain = '';
  38.        
  39.         //$this->session->set('cart', array());
  40.         if('POST' == $request->getMethod()){
  41.             $domain = $_POST['domain'];
  42.         
  43.         $api = new DomainNameAPI_PHPLibrary();
  44.         $api->setConnectionMethod('SOAP');
  45.         // Set Domain Name API Username and Password
  46.         $api->setUser("Famian", "ComputerAngel");
  47.     
  48.         // Enabling caching is recommended
  49.         $api->useCaching(true);
  50.         $api->useTestMode(false);
  51.         
  52.         // Check domain(s)
  53.         if($domain != ''){
  54.             $requestResults = $api->CheckAvailability(
  55.         
  56.                     // Second level domain as string array
  57.                     array(
  58.                         $domain
  59.                     ),
  60.                     
  61.                     // TLD as string array
  62.                     $tlds,
  63.                     //Period
  64.                     "1",
  65.                     //Command (create,renew,transfer,restore)
  66.                     "create"
  67.                 
  68.                 );
  69.             }
  70.             //var_dump($requestResults);
  71.             /* requestResults est un tableau qui contient un ensemble d'élément pour chaque domaine
  72.              Exemple pour chaque domaine
  73.              'DomainName' => string 'njk' (length=3)
  74.               'TLD' => string 'org' (length=3)
  75.               'Status' => string 'notavailable' (length=12)
  76.               'IsFee' => boolean false
  77.               'Currency' => string 'USD' (length=3)
  78.               'Command' => string 'create' (length=6)
  79.               'Period' => int 1
  80.               'Price' => string '9.0100' (length=6)
  81.               'ClassKey' => null
  82.               'Reason' => string 'In use' (length=6)
  83.             */
  84.         }
  86.         return $this->render('hosting/check_domain.html.twig', [
  87.                'results' => $requestResults['data'],
  88.                'domain' => $domain,
  89.             ]);
  90.           
  91.     }
  92.     
  93.    
  94.     
  95.     /**
  96.      * @Route("/add-to-cart", name="add_to_card")
  97.      */
  98.     public function addToCartAction($element = 'domain')
  99.     {
  100.         
  101.         $requestStack = $this->get('request_stack');
  103.         $request = $requestStack->getCurrentRequest();
  104.     
  105.         $em = $this->getDoctrine()
  106.                     ->getManager();
  107.         
  108.         $nombreProduit = (int)$this->session->get('nombreProduit');
  109.         $cart = (array)$this->session->get('cart');
  110.         $nomDeDomaine = '';
  111.         $tld = '';
  112.         $prix = '';
  113.         if('POST' == $request->getMethod() ){
  114.             $nomDeDomaine = $request->get('nom_de_domaine');
  115.             $tld = $request->get('tld');
  116.             $prix = $request->get('prix');
  117.             
  118.             $leDomaine = array();
  119.             if(array_key_exists($nomDeDomaine.$tld, $cart)){
  120.                 $cart[$nomDeDomaine.$tld]['year'] += 1;
  121.             } else{
  122.                 $leDomaine['nomDeDomaine'] = $nomDeDomaine;
  123.                 $leDomaine['tld'] = $tld;
  124.                 $leDomaine['prix'] = $prix;
  125.                 $leDomaine['year'] = 1;
  126.                 $leDomaine['id'] = $nomDeDomaine.$tld;
  128.                 $cart[$nomDeDomaine.$tld] = $leDomaine;
  129.             }
  130.             
  131.             $nombreProduit = count($cart);
  132.             
  133.             $montantDomaine = 0;
  134.             foreach($cart  as $domaine){
  135.                 $montantDomaine += $domaine['prix'] * $domaine['year'] ;
  136.             }
  137.             
  138.             $montantCommande = (float)$this->session->get('montantCommande');
  139.             $montantHebergement = (float)$this->session->get('montantHebergement');
  140.             $couponValue = (float)$this->session->get('couponValue');
  141.             $montantCommande = $montantDomaine - $couponValue + $montantHebergement;
  142.             $this->session->set('cart', $cart);
  143.             $this->session->set('montantDomaine', $montantDomaine);
  144.             $this->session->set('montantCommande', $montantCommande);
  145.             $this->session->set('montantHebergement', $montantHebergement);
  146.             $this->session->set('nombreProduit', $nombreProduit + 1);
  147.         }
  148.         
  149.         return new Response();
  150.     }
  152.      /**
  153.      * @Route("/register-domain", name="register_domain")
  154.      */
  155.     public function registerDomainAction(Request $request)
  156.     {
  157.         
  158.         
  159.         $api = new DomainNameAPI_PHPLibrary();
  160.         $api->setConnectionMethod('SOAP');
  161.         // Set Domain Name API Username and Password
  162.         $api->setUser("Famian", "ComputerAngel");
  163.     
  164.         // Enabling caching is recommended
  165.         $api->useCaching(true);
  166.         $api->useTestMode(false);
  167.         
  168.         // Register Domain
  169.     $result = $api->RegisterWithContactInfo(
  171.         // Domain name
  172.         "ofiber.pro", 
  173.         
  174.         // Years
  175.         1, 
  176.         
  177.         // Contact informations
  178.         array(
  179.             // Administrative contact
  180.             "Administrative" => array(
  181.                 "FirstName" => "Arnaud",
  182.                 "LastName" => "Kadio",
  183.                 "Company" => "Assie Group",
  184.                 "EMail" => "contact@assiemail.com",
  185.                 "AddressLine1" => "Port-Bouet SIPIM",
  186.                 "State" => "CI-Cote d'ivoire (Ivory Coast)",
  187.                 "City" => "Abidjan",
  188.                 "Country" => "CI",
  189.                 "Fax" => "",
  190.                 "FaxCountryCode" => "225",
  191.                 "Phone" => "0748946939",
  192.                 "PhoneCountryCode" => "225",
  193.                 "Type" => "Contact",
  194.                 "ZipCode" => "12 BP 245 Abidjan 12",
  195.                 "Status" => ""
  196.             ),
  197.             
  198.             // Billing contact
  199.             "Billing" => array(
  200.                 "FirstName" => "Arnaud",
  201.                 "LastName" => "Kadio",
  202.                 "Company" => "Assie Group",
  203.                 "EMail" => "contact@assiemail.com",
  204.                 "AddressLine1" => "Port-Bouet SIPIM",
  205.                 "State" => "CI-Cote d'ivoire (Ivory Coast)",
  206.                 "City" => "Abidjan",
  207.                 "Country" => "CI",
  208.                 "Fax" => "",
  209.                 "FaxCountryCode" => "225",
  210.                 "Phone" => "0748946939",
  211.                 "PhoneCountryCode" => "225",
  212.                 "Type" => "Contact",
  213.                 "ZipCode" => "12 BP 245 Abidjan 12",
  214.                 "Status" => ""
  215.             ),
  216.             
  217.             // Technical contact
  218.             "Technical" => array(
  219.                 "FirstName" => "Arnaud",
  220.                 "LastName" => "Kadio",
  221.                 "Company" => "Assie Group",
  222.                 "EMail" => "contact@assiemail.com",
  223.                 "AddressLine1" => "Port-Bouet SIPIM",
  224.                 "State" => "CI-Cote d'ivoire (Ivory Coast)",
  225.                 "City" => "Abidjan",
  226.                 "Country" => "CI",
  227.                 "Fax" => "",
  228.                 "FaxCountryCode" => "225",
  229.                 "Phone" => "0748946939",
  230.                 "PhoneCountryCode" => "225",
  231.                 "Type" => "Contact",
  232.                 "ZipCode" => "12 BP 245 Abidjan 12",
  233.                 "Status" => ""
  234.             ),
  235.             
  236.             // Registrant contact
  237.             "Registrant" => array(
  238.                 "FirstName" => "Arnaud",
  239.                 "LastName" => "Kadio",
  240.                 "Company" => "Assie Group",
  241.                 "EMail" => "contact@assiemail.com",
  242.                 "AddressLine1" => "Port-Bouet SIPIM",
  243.                 "State" => "CI-Cote d'ivoire (Ivory Coast)",
  244.                 "City" => "Abidjan",
  245.                 "Country" => "CI",
  246.                 "Fax" => "",
  247.                 "FaxCountryCode" => "225",
  248.                 "Phone" => "0748946939",
  249.                 "PhoneCountryCode" => "225",
  250.                 "Type" => "Contact",
  251.                 "ZipCode" => "12 BP 245 Abidjan 12",
  252.                 "Status" => ""
  253.             ),
  254.             
  255.         ),
  256.         
  257.         // Nameservers
  258.         array("ns327485.ip-37-187-110.eu", "ns.kimsufi.com"),
  259.     
  260.         // Theft protection lock enabled
  261.         true,
  262.     
  263.         // Privacy Protection enabled
  264.         true
  265.         
  266.     );
  268.     var_dump($result);
  270.         return $this->render('hosting/register_domain.html.twig', [
  271.                
  272.                
  273.             ]);
  274.           
  275.     }
  276.     
  277.     /**
  278.      * @Route("/cart", name="cart")
  279.      */
  280.     public function cartAction(Request $request)
  281.     {
  282.         
  283.         $results = array();
  284.         $domain = '';
  285.         $plans = array();
  287.         $cart = (array)$this->session->get('cart');
  288.         $montantCommande = $this->session->get('montantCommande');
  289.         $montantHebergement = $this->session->get('montantHebergement');
  290.         $nombreProduit = $this->session->get('nombreProduit');
  292.         return $this->render('hosting/cart.html.twig', [
  293.                'plans' => $plans,
  294.                'cart' => $cart,
  295.                'montantCommande' => $montantCommande,
  296.                'montantHebergement' => $montantHebergement,
  297.                'nombreProduit' => $nombreProduit
  298.             ]);
  299.           
  300.     }
  301.     
  302.     /**
  303.      * @Route("/top-menu-cart", name="top_menu_cart")
  304.      */
  305.     public function topMenucartAction(Request $request)
  306.     {
  307.         $nombreProduit = $this->session->get('nombreProduit');
  309.         return $this->render('hosting/top_menu_cart.html.twig', [
  310.                'nombreProduit' => $nombreProduit
  311.             ]);
  312.           
  313.     }
  315.     /**
  316.      * @Route("/update-cart/", name="update_cart")
  317.      */
  318.     public function updateCartAction()
  319.     {
  320.         
  321.         $requestStack = $this->get('request_stack');
  323.         $request = $requestStack->getCurrentRequest();
  324.     
  325.         $em = $this->getDoctrine()
  326.                     ->getManager();
  327.         
  328.         $cart = (array)$this->session->get('cart');
  329.         $product = '';
  330.         $price = '';
  331.         
  332.         if('POST' == $request->getMethod() ){
  334.             
  335.             $product = $request->get('product');
  336.             $year = $request->get('year');
  337.             
  338.             $leProduct = array();
  340.             $cart[$product]['year'] = $year;
  341.             
  342.             $montantDomaine = 0;
  343.             foreach($cart  as $prod){
  344.                 $montantDomaine += $prod['prix'] *  $prod['year'];
  345.             }
  346.             
  347.             $couponValue = (float)$this->session->get('couponValue');
  348.             $montantHebergement = (float)$this->session->get('montantHebergement');
  349.             
  350.             $montantCommande = $montantDomaine - $couponValue + $montantHebergement;
  351.             $this->session->set('cart', $cart);
  352.             $this->session->set('montantDomaine', $montantDomaine);
  353.             $this->session->set('montantCommande', $montantCommande);
  354.             $this->session->set('montantHebergement', $montantHebergement);
  355.         }
  356.         
  357.         return $this->redirectToRoute('cart');
  358.     }
  359.     
  360.     /**
  361.      * @Route("/cart-side-section", name="cart_side_session")
  362.      */
  363.     public function cartSideSessionAction()
  364.     {
  365.         
  366.         $requestStack = $this->get('request_stack');
  368.         $request = $requestStack->getCurrentRequest();
  369.     
  370.         $em = $this->getDoctrine()
  371.                     ->getManager();
  372.         
  373.         $nombreProduit = (int)$this->session->get('nombreProduct');
  374.         $montantCommande = (float)$this->session->get('montantCommande');
  375.         $montantHebergement = (float)$this->session->get('montantHebergement');
  376.         $montantDomaine = (float)$this->session->get('montantDomaine');
  377.         $couponValue = (float)$this->session->get('couponValue');
  378.         $cart = (array)$this->session->get('cart');
  379.         
  380.         
  381.         return $this->render('hosting/cart_side_session.html.twig', [
  382.             'cart' => $cart,
  383.             'nombreProduit' => $nombreProduit,
  384.             'montantDomaine' => $montantDomaine,
  385.             'montantCommande' => $montantCommande,
  386.             'montantHebergement' => $montantHebergement,
  387.             'couponValue' => $couponValue
  388.         ]);
  389.     }
  390.     
  391.     /**
  392.      * @Route("/apply-coupon", name="apply_coupon")
  393.      */
  394.     public function applayCouponAction()
  395.     {
  396.         $requestStack = $this->get('request_stack');
  398.         $request = $requestStack->getCurrentRequest();
  399.     
  400.         $em = $this->getDoctrine()
  401.                     ->getManager();
  402.         if('POST' == $request->getMethod() ){
  403.             $coupon = $request->get('coupon');
  404.             
  405.             $coupon = $em->getRePository(Coupon::class)
  406.                         ->findOneByCode($coupon);
  407.             if(null != $coupon){
  408.                 $toDay = new \DateTime();
  409.                     
  410.                 if($coupon->getDateDebut() <= $toDay
  411.                     && $toDay <= $coupon->getDateFin()
  412.                     //&& $coupon->getUsageLimit() > (integer)$coupon->getActualUsage()
  413.                     ){
  414.                         
  415.                         $codePromo = $this->session->get('codePromo');
  416.                         
  417.                         if($codePromo != $coupon->getCode()){
  418.                             $this->session->set('codePromo', $coupon->getCode());
  419.                             $montantCommande = (float)$this->session->get('montantCommande');
  420.                             if($coupon->getIsPercentage()){
  421.                                 
  422.                                 $couponValue = ($montantCommande *  $coupon->getCouponValue())/100;
  423.                             } else{
  424.                                 $couponValue = $coupon->getCouponValue();
  425.                             }
  426.                             $this->session->set('couponValue', $couponValue);
  427.                             $montantCommande = $montantCommande - $couponValue;
  428.                             $this->session->set('montantCommande', $montantCommande);
  429.                         } else{
  430.                             
  431.                         }
  432.                     } else{
  433.                         
  434.                     }
  435.             }
  436.         }
  437.         
  438.         return $this->redirectToRoute('cart');
  439.         //return new Response();
  440.     }
  441.     
  442.     
  443.     /**
  444.      * @Route("/delete-cart-item/{product}", name="delete_cart_item")
  445.      */
  446.     public function deleteCartItemAction($product)
  447.     {
  448.         
  449.         $requestStack = $this->get('request_stack');
  451.         $request = $requestStack->getCurrentRequest();
  452.     
  453.         $em = $this->getDoctrine()
  454.                     ->getManager();
  455.         
  456.         $nombreProduct = (int)$this->session->get('nombreProduct');
  457.         $cart = (array)$this->session->get('cart');
  458.         
  459.         $montantProduct = $this->session->get('montantProduct');
  460.         $couponValue = (float)$this->session->get('couponValue');
  461.         $montantOrder = (float)$this->session->get('montantOrder');
  462.         $montantProduct = $montantProduct - ($cart[$product]['year'] * $cart[$product]['prix']);
  463.         unset($cart[$product]);
  464.             
  465.         $nombreProduct = count($cart);
  466.         $montantOrder = $montantProduct  - $couponValue;
  467.         
  468.         $this->session->set('cart', $cart);
  469.         $this->session->set('nombreProduct', $nombreProduct);
  470.         $this->session->set('montantProduct', $montantProduct);
  471.         $this->session->set('montantOrder', $montantOrder);
  472.         
  473.         return $this->redirectToRoute('cart');
  474.           
  475.     }
  476.     
  477.     /**
  478.      * @Route("/empty-cart", name="empty_cart")
  479.      */
  480.     public function emptycartAction()
  481.     {
  482.         
  483.             $this->emptyRealCart();
  484.         
  485.         return $this->redirectToRoute('cart');
  486.     }
  487.     
  488.     public function emptyRealCart()
  489.     {
  490.         $this->session->set('cart', array());
  491.         $this->session->set('nombreProduit', '');
  492.         $this->session->set('montantProduct', 0);
  493.         $this->session->set('montantHebergement', 0);
  494.         $this->session->set('montantDomaine', 0);
  495.         $this->session->set('montantCommande', 0);
  496.         $this->session->set('paymentMethod', '');
  497.         $this->session->set('couponValue', 0);
  498.         $this->session->set('codePromo', '');
  499.     }
  500.     
  501.     /**
  502.      * @Route("/choose-hosting-plan", name="choose_hosting_plan")
  503.      */
  504.     public function chooseHostingPlanAction(Request $request)
  505.     {
  506.         
  507.         $results = array();
  508.         $domain = '';
  509.         $plans = array();
  511.         return $this->render('hosting/choose_hosting_plan.html.twig', [
  512.                'plans' => $plans
  513.             ]);
  514.           
  515.     }
  516.     
  517. }
  520. // BASE CONNECTION (ABSTRACT)
  521. abstract class APIConnection
  522. {
  524.     abstract public function CheckAvailability($parameters);
  526.     abstract public function ModifyNameServer($parameters);
  527.     
  528.     abstract public function GetList($parameters);
  529.     abstract public function GetDetails($parameters);
  530.     
  531.     abstract public function EnableTheftProtectionLock($parameters);
  532.     abstract public function DisableTheftProtectionLock($parameters);
  533.     
  534.     abstract public function ModifyPrivacyProtectionStatus($parameters);
  535.     
  536.     abstract public function AddChildNameServer($parameters);
  537.     abstract public function DeleteChildNameServer($parameters);
  538.     abstract public function ModifyChildNameServer($parameters);
  539.     
  540.     abstract public function GetContacts($parameters);
  541.     abstract public function SaveContacts($parameters);
  543.     abstract public function Transfer($parameters);
  544.     abstract public function CancelTransfer($parameters);
  546.     abstract public function RegisterWithContactInfo($parameters);
  547.     abstract public function Renew($parameters);
  548.     abstract public function Delete($parameters);
  549.     
  550.     abstract public function SyncFromRegistry($parameters);
  551.     abstract public function CheckTransfer($parameters);
  552. }
  554. // SOAP CONNECTION
  555. class APIConnection_SOAP extends APIConnection
  556. {
  557.     // VARIABLES
  558.     private $service = null;
  559.     private $URL_SERVICE = "";
  561.     // CONSTRUCTORS
  562.     function __construct($Service_URL) 
  563.     {
  564.         // Set settings
  565.         $this->URL_SERVICE = $Service_URL;
  567.         // Set WSDL caching enabled     
  568.         ini_set('soap.wsdl_cache_enabled', '1'); ini_set('soap.wsdl_cache_ttl', '86400'); 
  570.         // Create unique connection
  571.         $this->service = new \SoapClient($this->URL_SERVICE . "?singlewsdl", array("cache_wsdl" => WSDL_CACHE_MEMORY,  "encoding"=>"UTF-8")); 
  572.     }
  573.     function APIConnection_SOAP($Service_URL) 
  574.     {
  575.         // Set settings
  576.         $this->URL_SERVICE = $Service_URL; //05 85 152 077
  577.         
  578.         // Set WSDL caching enabled
  579.         ini_set('soap.wsdl_cache_enabled', '1');  ini_set('soap.wsdl_cache_ttl', '86400'); 
  581.         // Create unique connection
  582.         $this->service = new \SoapClient($this->URL_SERVICE . "?singlewsdl", array("cache_wsdl" => WSDL_CACHE_MEMORY,  "encoding"=>"UTF-8")); 
  583.     }
  584.     
  585.     // Convert object to array
  586.     private function objectToArray($o) 
  587.     {
  588.         try { $o = json_decode(json_encode($o), true); } catch(Exception $ex) { }
  589.         return $o;
  590.     }
  591.     
  592.     // Get error if exists
  593.     private function parseError($response)
  594.     {
  595.         $result = false;
  597.         if(is_null($response))
  598.         {
  599.             // Set error data
  600.             $result = array();
  601.             $result["Code"] = "INVALID_RESPONSE";
  602.             $result["Message"] = "Invalid response or no response received from server!";
  603.             $result["Details"] = "SOAP Connection returned null value!";
  604.         }
  605.         elseif(!is_array($response))
  606.         {
  607.             // Set error data
  608.             $result = array();
  609.             $result["Code"] = "INVALID_RESPONSE";
  610.             $result["Message"] = "Invalid response or no response received from server!";
  611.             $result["Details"] = "SOAP Connection returned non-array value!";
  612.         }
  613.         elseif(strtolower(key($response)) == "faultstring")
  614.         {
  615.             // Handle soap fault
  616.             
  617.             $result = array();
  618.             $result["Code"] = "";
  619.             $result["Message"] = "";
  620.             $result["Details"] = "";
  621.             
  622.             // Set error data
  623.             if(isset($response["faultcode"])) { $result["Code"] = $response["faultcode"]; }
  624.             if(isset($response["faultstring"])) { $result["Message"] = $response["faultstring"]; }
  625.             if(isset($response["detail"])) {
  626.                 if(is_array($response["detail"])) {
  627.                     if(isset($response["detail"]["ExceptionDetail"])) {
  628.                         if(is_array($response["detail"]["ExceptionDetail"])) {
  629.                             if(isset($response["detail"]["ExceptionDetail"]["StackTrace"]))
  630.                             { $result["Details"] = $response["detail"]["ExceptionDetail"]["StackTrace"]; }
  631.                         }
  632.                     }
  633.                 
  634.                 }
  635.             }
  636.             
  637.         }
  638.         elseif(count($response) != 1)
  639.         {
  640.             // Set error data
  641.             $result = array();
  642.             $result["Code"] = "INVALID_RESPONSE";
  643.             $result["Message"] = "Invalid response or no response received from server!";
  644.             $result["Details"] = "Response data contains more than one result! Only one result accepted!";
  645.         }
  646.         elseif(!isset($response[key($response)]["OperationResult"]) || !isset($response[key($response)]["ErrorCode"]))
  647.         {
  648.             // Set error data
  649.             $result = array();
  650.             $result["Code"] = "INVALID_RESPONSE";
  651.             $result["Message"] = "Invalid response or no response received from server!";
  652.             $result["Details"] = "Operation result or Error code not received from server!";
  653.         }
  654.         elseif(strtoupper($response[key($response)]["OperationResult"]) != "SUCCESS")
  655.         {
  656.             // Set error data
  657.             $result = array();
  658.             $result["Code"] = "";
  659.             $result["Message"] = "";
  660.             $result["Details"] = "";
  661.             
  662.             $result["Message"] = "Operation can not completed successfully!";
  664.             if(isset($response[key($response)]["OperationMessage"]))
  665.             { $result["Code"] = "API_" . $response[key($response)]["ErrorCode"]; }
  667.             if(isset($response[key($response)]["OperationResult"]))
  668.             { $result["Code"] .= "_" . $response[key($response)]["OperationResult"]; }
  670.             if(isset($response[key($response)]["OperationMessage"]))
  671.             { $result["Details"] = $response[key($response)]["OperationMessage"]; }
  672.             
  673.         }
  674.         else
  675.         {
  676.             
  677.         }
  679.         return $result;
  680.     }
  681.     
  682.     // Check if response contains error
  683.     private function hasError($response)
  684.     { return ($this->parseError($response) === false) ? false : true; }
  685.     
  686.     // Set error message
  687.     private function setError($Code, $Message, $Details)
  688.     {
  689.         $result = array();
  690.         $result["Code"] = $Code;
  691.         $result["Message"] = $Message;
  692.         $result["Details"] = $Details;
  693.         return $result;
  694.     }
  695.     
  696.     // Parse domain info
  697.     private function parseDomainInfo($data)
  698.     {
  699.         $result = array();
  700.         $result["ID"] = "";
  701.         $result["Status"] = "";
  702.         $result["DomainName"] = "";
  703.         $result["AuthCode"] = "";
  704.         $result["LockStatus"] = "";
  705.         $result["PrivacyProtectionStatus"] = "";
  706.         $result["IsChildNameServer"] = "";
  707.         $result["Contacts"] = array();
  708.         $result["Contacts"]["Billing"] = array();
  709.         $result["Contacts"]["Technical"] = array();
  710.         $result["Contacts"]["Administrative"] = array();
  711.         $result["Contacts"]["Registrant"] = array();
  712.         $result["Contacts"]["Billing"]["ID"] = "";
  713.         $result["Contacts"]["Technical"]["ID"] = "";
  714.         $result["Contacts"]["Administrative"]["ID"] = "";
  715.         $result["Contacts"]["Registrant"]["ID"] = "";
  716.         $result["Dates"] = array();
  717.         $result["Dates"]["Start"] = "";
  718.         $result["Dates"]["Expiration"] = "";
  719.         $result["Dates"]["RemainingDays"] = "";
  720.         $result["NameServers"] = array();
  721.         $result["Additional"] = array();
  722.         $result["ChildNameServers"] = array();
  723.         
  724.         foreach($data as $attrName => $attrValue)
  725.         {
  726.             switch($attrName)
  727.             {
  728.                 case "Id":
  729.                 {
  730.                     if(is_numeric($attrValue)) { $result["ID"] = $attrValue; }
  731.                     break;
  732.                 }
  733.                 
  734.                 case "Status":
  735.                 { $result["Status"] = $attrValue; break; }
  736.                     
  737.                 case "DomainName":
  738.                 { $result["DomainName"] = $attrValue; break; }
  739.                 
  740.                 case "AdministrativeContactId":
  741.                 { 
  742.                     if(is_numeric($attrValue)) { $result["Contacts"]["Administrative"]["ID"] = $attrValue;  }
  743.                     break; 
  744.                 }
  745.                 
  746.                 case "BillingContactId":
  747.                 { 
  748.                     if(is_numeric($attrValue)) { $result["Contacts"]["Billing"]["ID"] = $attrValue;  }
  749.                     break; 
  750.                 }
  751.                 
  752.                 case "TechnicalContactId":
  753.                 { 
  754.                     if(is_numeric($attrValue)) { $result["Contacts"]["Technical"]["ID"] = $attrValue;  }
  755.                     break; 
  756.                 }
  757.                 
  758.                 case "RegistrantContactId":
  759.                 { 
  760.                     if(is_numeric($attrValue)) { $result["Contacts"]["Registrant"]["ID"] = $attrValue;  }
  761.                     break; 
  762.                 }
  763.                 
  764.                 case "Auth":
  765.                 {
  766.                     if(is_string($attrValue) && !is_null($attrValue))
  767.                     { $result["AuthCode"] = $attrValue; }
  768.                     break;
  769.                 }
  770.                 
  771.                 case "StartDate":
  772.                 { $result["Dates"]["Start"] = $attrValue; break; }
  773.                 
  774.                 case "ExpirationDate":
  775.                 { $result["Dates"]["Expiration"] = $attrValue; break; }
  776.                 
  777.                 case "LockStatus":
  778.                 { 
  779.                     if(is_bool($attrValue))
  780.                     { $result["LockStatus"] = var_export($attrValue, true); }
  781.                     break; 
  782.                 }
  783.                 
  784.                 case "PrivacyProtectionStatus":
  785.                 { 
  786.                     if(is_bool($attrValue))
  787.                     { $result["PrivacyProtectionStatus"] = var_export($attrValue, true); }
  788.                     break; 
  789.                 }
  790.                 
  791.                 case "IsChildNameServer":
  792.                 { 
  793.                     if(is_bool($attrValue))
  794.                     { $result["IsChildNameServer"] = var_export($attrValue, true); }
  795.                     break; 
  796.                 }
  797.                 
  798.                 case "RemainingDay":
  799.                 { 
  800.                     if(is_numeric($attrValue))
  801.                     { $result["Dates"]["RemainingDays"] = $attrValue; }
  802.                     break; 
  803.                 }
  804.                 
  805.                 case "NameServerList":
  806.                 { 
  807.                     if(is_array($attrValue))
  808.                     {
  809.                         foreach($attrValue as $nameserverValue)
  810.                         {
  811.                             array_push($result["NameServers"], $nameserverValue);
  812.                         }
  813.                     }
  814.                     break; 
  815.                 }
  816.                 
  817.                 case "AdditionalAttributes":
  818.                 { 
  819.                     if(is_array($attrValue))
  820.                     {
  822.                         if(isset($attrValue["KeyValueOfstringstring"]))
  823.                         {
  824.                             foreach($attrValue["KeyValueOfstringstring"] as $attribute)
  825.                             {
  826.                                 if(isset($attribute["Key"]) && isset($attribute["Value"]))
  827.                                 {
  828.                                     $result["Additional"][$attribute["Key"]] = $attribute["Value"];
  829.                                 }
  830.                             }
  831.                         }
  832.                     }
  833.                     break; 
  834.                 }
  835.                 
  836.                 case "ChildNameServerInfo":
  837.                 {
  839.                     if(is_array($attrValue))
  840.                     {
  841.                     
  842.                         if(isset($attrValue["ChildNameServerInfo"]["IpAddress"]))
  843.                         {
  844.                             $attribute = $attrValue["ChildNameServerInfo"];
  845.                         
  846.                             $ns = "";
  847.                             $IpAddresses = array();
  849.                             // Name of NameServer
  850.                             if(!is_null($attribute["NameServer"]) && is_string($attribute["NameServer"]))
  851.                             { $ns = $attribute["NameServer"]; }
  852.                              
  853.                             // IP adresses of NameServer
  854.                             if(is_array($attribute["IpAddress"]) && isset($attribute["IpAddress"]["string"]))
  855.                             {
  856.                                     
  857.                                 if(is_array($attribute["IpAddress"]["string"]))
  858.                                 {
  859.                                     
  860.                                     foreach($attribute["IpAddress"]["string"] as $ip)
  861.                                     {
  862.                                         if(isset($ip) && !is_null($ip) && is_string($ip))
  863.                                         {
  864.                                             array_push($IpAddresses, $ip);
  865.                                         }
  866.                                     }
  867.                                 
  868.                                 }
  869.                                 elseif(is_string($attribute["IpAddress"]["string"]))
  870.                                 {
  871.                                     array_push($IpAddresses, $attribute["IpAddress"]["string"]);
  872.                                 }
  873.                                 
  874.                             }
  875.                             
  876.                             array_push($result["ChildNameServers"], 
  877.                                 array(
  878.                                     "NameServer" => $ns,
  879.                                     "IPAddresses" => $IpAddresses
  880.                                 )
  881.                             );
  882.                             
  884.                         }
  885.                         else
  886.                         {
  887.                             if(count($attrValue["ChildNameServerInfo"])>0)
  888.                             {
  889.                                 foreach($attrValue["ChildNameServerInfo"] as $attribute)
  890.                                 {
  891.         
  892.                                     if(isset($attribute["NameServer"]) && isset($attribute["IpAddress"]))
  893.                                     {
  894.                                         $ns = "";
  895.                                         $IpAddresses = array();
  896.         
  897.                                         // Name of NameServer
  898.                                         if(!is_null($attribute["NameServer"]) && is_string($attribute["NameServer"]))
  899.                                         { $ns = $attribute["NameServer"]; }
  900.                                          
  901.                                         // IP adresses of NameServer
  902.                                         if(is_array($attribute["IpAddress"]) && isset($attribute["IpAddress"]["string"]))
  903.                                         {
  904.                                                 
  905.                                             if(is_array($attribute["IpAddress"]["string"]))
  906.                                             {
  907.                                                 
  908.                                                 foreach($attribute["IpAddress"]["string"] as $ip)
  909.                                                 {
  910.                                                     if(isset($ip) && !is_null($ip) && is_string($ip))
  911.                                                     {
  912.                                                         array_push($IpAddresses, $ip);
  913.                                                     }
  914.                                                 }
  915.                                             
  916.                                             }
  917.                                             elseif(is_string($attribute["IpAddress"]["string"]))
  918.                                             {
  919.                                                 array_push($IpAddresses, $attribute["IpAddress"]["string"]);
  920.                                             }
  921.                                             
  922.                                         }
  923.                                         
  924.                                         array_push($result["ChildNameServers"], 
  925.                                             array(
  926.                                                 "NameServer" => $ns,
  927.                                                 "IPAddresses" => $IpAddresses
  928.                                             )
  929.                                         );
  930.                                         
  931.                                         
  932.                                         
  933.                                     }
  934.                                     
  935.                                 }    
  936.                                 
  937.                             }                    
  938.                         }
  940.                         
  941.                     }
  942.                     break;
  943.                 }
  944.             }
  946.         }
  948.         return $result;
  949.     }
  950.     
  951.     
  952.     
  954.     // Parse Contact info
  955.     private function parseContactInfo($data)
  956.     {
  957.         $result = array();
  958.         $result["ID"] = "";
  959.         $result["Status"] = "";
  960.         $result["Additional"] = array();
  961.         $result["Address"] = array();
  962.         $result["Address"]["Line1"] = "";
  963.         $result["Address"]["Line2"] = "";
  964.         $result["Address"]["Line3"] = "";
  965.         $result["Address"]["State"] = "";
  966.         $result["Address"]["City"] = "";
  967.         $result["Address"]["Country"] = "";
  968.         $result["Address"]["ZipCode"] = "";
  969.         $result["Phone"] = array();
  970.         $result["Phone"]["Phone"] = array();
  971.         $result["Phone"]["Phone"]["Number"] = "";
  972.         $result["Phone"]["Phone"]["CountryCode"] = "";
  973.         $result["Phone"]["Fax"]["Number"] = "";
  974.         $result["Phone"]["Fax"]["CountryCode"] = "";
  975.         $result["AuthCode"] = "";
  976.         $result["FirstName"] = "";
  977.         $result["LastName"] = "";
  978.         $result["Company"] = "";
  979.         $result["EMail"] = "";
  980.         $result["Type"] = "";
  981.         
  982.         foreach($data as $attrName => $attrValue)
  983.         {
  984.             switch($attrName)
  985.             {
  986.                 case "Id":
  987.                 {
  988.                     if(is_numeric($attrValue)) { $result["ID"] = $attrValue; }
  989.                     break;
  990.                 }
  991.                 
  992.                 case "Status":
  993.                 { $result["Status"] = $attrValue; break; }
  995.                 case "AdditionalAttributes":
  996.                 { 
  997.                     if(is_array($attrValue))
  998.                     {
  1000.                         if(isset($attrValue["KeyValueOfstringstring"]))
  1001.                         {
  1002.                             foreach($attrValue["KeyValueOfstringstring"] as $attribute)
  1003.                             {
  1004.                                 if(isset($attribute["Key"]) && isset($attribute["Value"]))
  1005.                                 {
  1006.                                     $result["Additional"][$attribute["Key"]] = $attribute["Value"];
  1007.                                 }
  1008.                             }
  1009.                         }
  1010.                     }
  1011.                     break; 
  1012.                 }
  1014.                 case "AddressLine1":
  1015.                 { 
  1016.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Address"]["Line1"] = $attrValue;  }
  1017.                     break; 
  1018.                 }
  1019.                 
  1020.                 case "AddressLine2":
  1021.                 { 
  1022.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Address"]["Line2"] = $attrValue;  }
  1023.                     break; 
  1024.                 }
  1025.                 
  1026.                 case "AddressLine3":
  1027.                 { 
  1028.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Address"]["Line3"] = $attrValue;  }
  1029.                     break; 
  1030.                 }
  1031.                 
  1032.                 case "Auth":
  1033.                 {
  1034.                     if(is_string($attrValue) && !is_null($attrValue))
  1035.                     { $result["AuthCode"] = $attrValue; }
  1036.                     break;
  1037.                 }
  1038.                 
  1039.                 case "City":
  1040.                 { 
  1041.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Address"]["City"] = $attrValue;  }
  1042.                     break; 
  1043.                 }
  1044.                 
  1045.                 case "Company":
  1046.                 { 
  1047.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Company"] = $attrValue;  }
  1048.                     break; 
  1049.                 }
  1050.                 
  1051.                 case "Country":
  1052.                 { 
  1053.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Address"]["Country"] = $attrValue;  }
  1054.                     break; 
  1055.                 }
  1056.                 
  1057.                 case "EMail":
  1058.                 { 
  1059.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["EMail"] = $attrValue;  }
  1060.                     break; 
  1061.                 }
  1062.                 
  1063.                 case "Fax":
  1064.                 { 
  1065.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Phone"]["Fax"]["Number"] = $attrValue;  }
  1066.                     break; 
  1067.                 }
  1068.                 
  1069.                 case "FaxCountryCode":
  1070.                 { 
  1071.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Phone"]["Fax"]["CountryCode"] = $attrValue;  }
  1072.                     break; 
  1073.                 }
  1074.                 
  1075.                 case "Phone":
  1076.                 { 
  1077.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Phone"]["Phone"]["Number"] = $attrValue;  }
  1078.                     break; 
  1079.                 }
  1080.                 
  1081.                 case "PhoneCountryCode":
  1082.                 { 
  1083.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Phone"]["Phone"]["CountryCode"] = $attrValue;  }
  1084.                     break; 
  1085.                 }
  1086.                 
  1087.                 case "FirstName":
  1088.                 { 
  1089.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["FirstName"] = $attrValue;  }
  1090.                     break; 
  1091.                 }
  1092.                 
  1093.                 case "LastName":
  1094.                 { 
  1095.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["LastName"] = $attrValue;  }
  1096.                     break; 
  1097.                 }
  1098.                 
  1099.                 case "State":
  1100.                 { 
  1101.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Address"]["State"] = $attrValue;  }
  1102.                     break; 
  1103.                 }
  1104.                 
  1105.                 case "ZipCode":
  1106.                 { 
  1107.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Address"]["ZipCode"] = $attrValue;  }
  1108.                     break; 
  1109.                 }
  1110.                 
  1111.                 case "Type":
  1112.                 { 
  1113.                     if(is_string($attrValue) && !is_null($attrValue)) { $result["Type"] = $attrValue;  }
  1114.                     break; 
  1115.                 }
  1116.                 
  1117.             }
  1119.         }
  1121.         return $result;
  1122.     }
  1123.     
  1124.     // API METHODs
  1125.     
  1126.     // Check domain is available?
  1127.     public function CheckAvailability($parameters)
  1128.     {
  1129.         $result = array();
  1131.         $TldSayisi=count($parameters["request"]["TldList"]);
  1132.         
  1133.         try
  1134.         {
  1135.             // SOAP method which is same as current function name called
  1136.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1138.         
  1139.             // Serialize as array
  1140.             $response = $this->objectToArray($response);
  1141.             
  1142.             // Check is there any error?
  1144.                 if(!$this->hasError($response))
  1145.                     { 
  1147.                         if($TldSayisi>1){
  1148.                                 $data = $response[key($response)];
  1149.                                 
  1150.                                 if(isset($data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"])) {
  1151.                                     if(is_array($data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"])) {
  1152.                                         $result["data"] = array();
  1153.                                         
  1154.                                         foreach($data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"] as $name => $value) {
  1155.                                             array_push($result["data"], 
  1156.                                                 array(  "DomainName" => $value["DomainName"],//Domain adı
  1157.                                                         "TLD" => $value["Tld"], // Uzantı
  1158.                                                         "Status" => $value["Status"], // Domain alınabilirlik durumu available notavailable
  1159.                                                         "IsFee" => $value["IsFee"], // Domain Premium mu True /False
  1160.                                                         "Currency" => $value["Currency"],// Doviz kuru
  1161.                                                         "Command" => $value["Command"], // Komut create,renew,transfer,restore fiyatlarının çekilmesi
  1162.                                                         "Period" => $value["Period"], // Domain Periyodu
  1163.                                                         "Price" => $value["Price"], // Domain Fiyatı
  1164.                                                         "ClassKey" => $value["ClassKey"], //Premium domainin açıklaması
  1165.                                                         "Reason" => $value["Reason"] //Domain ile ilgili özel durumlar rezerve dilmiş  veya alınamıyor gibi
  1166.                                                 )
  1167.                                             );
  1168.                                         }
  1170.                                         $result["result"] = "OK";
  1172.                                     }
  1173.                                     else
  1174.                                     {
  1175.                                         $result["result"] = "ERROR";
  1176.                                         $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain list is not valid!");;
  1177.                                     }
  1178.                                 }
  1179.                                 else
  1180.                                 {
  1181.                                     $result["result"] = "ERROR";
  1182.                                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain list is not valid!");;
  1183.                                 } 
  1184.                             }else{
  1186.                                $data = $response[key($response)];
  1187.                                 
  1188.                                 if(isset($data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"])) {
  1189.                                     if(is_array($data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"])) {
  1190.                                         $result["data"] = array(); 
  1192.                                             array_push($result["data"], 
  1193.                                                 array(  "DomainName" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["DomainName"],//Domain adı
  1194.                                                         "TLD" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["Tld"], // Uzantı
  1195.                                                         "Status" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["Status"], // Domain alınabilirlik durumu available notavailable
  1196.                                                         "IsFee" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["IsFee"], // Domain Premium mu True /False
  1197.                                                         "Currency" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["Currency"],// Doviz kuru
  1198.                                                         "Command" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["Command"], // Komut create,renew,transfer,restore fiyatlarının çekilmesi
  1199.                                                         "Period" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["Period"], // Domain Periyodu
  1200.                                                         "Price" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["Price"], // Domain Fiyatı
  1201.                                                         "ClassKey" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["ClassKey"], //Premium domainin açıklaması
  1202.                                                         "Reason" => $data["DomainAvailabilityInfoList"]["DomainAvailabilityInfo"]["Reason"] //Domain ile ilgili özel durumlar rezerve dilmiş  veya alınamıyor gibi
  1203.                                                 )
  1204.                                             );
  1205.                                         
  1207.                                         $result["result"] = "OK";
  1209.                                     }
  1210.                                     else
  1211.                                     {
  1212.                                         $result["result"] = "ERROR";
  1213.                                         $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain list is not valid!");;
  1214.                                     }
  1215.                                 }
  1216.                                 else
  1217.                                 {
  1218.                                     $result["result"] = "ERROR";
  1219.                                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain list is not valid!");;
  1220.                                 }
  1221.                             }
  1222.                     }
  1225.             else
  1226.             {
  1227.                 // Hata mesajini dondur
  1228.                 $result["result"] = "ERROR";
  1229.                 $result["error"] = $this->parseError($response);
  1230.             }
  1231.             
  1232.         }
  1233.         catch(Exception $ex)
  1234.         {
  1235.             $result["result"] = "ERROR";
  1236.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1237.         }
  1238.         
  1239.         return $result;
  1240.     }
  1242.     
  1243.     // Get domain list
  1244.     public function GetList($parameters)
  1245.     {
  1246.         $result = array();
  1247.         
  1248.         try
  1249.         {
  1250.             // SOAP method which is same as current function name called
  1251.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1253.             // Serialize as array
  1254.             $response = $this->objectToArray($response);
  1255.             
  1256.             // Check is there any error?
  1257.             if(!$this->hasError($response))
  1258.             {
  1259.                 $data = $response[key($response)];
  1261.                 // If DomainInfo a valid array
  1262.                 if(isset($data["TotalCount"]) && is_numeric($data["TotalCount"]))
  1263.                 {
  1264.                     $result["data"]["Domains"] = array();
  1265.                     
  1266.                     if(isset($data["DomainInfoList"]) && is_array($data["DomainInfoList"]))
  1267.                     {
  1268.                         if(isset($data["DomainInfoList"]["DomainInfo"]["Id"]))
  1269.                         {
  1270.                             array_push($result["data"]["Domains"], $data["DomainInfoList"]["DomainInfo"]);
  1271.                         }
  1272.                         else
  1273.                         {
  1274.                             // Parse multiple domain info
  1275.                             foreach($data["DomainInfoList"]["DomainInfo"] as $domainInfo)
  1276.                             {
  1277.                                 array_push($result["data"]["Domains"], $this->parseDomainInfo($domainInfo));
  1278.                             }                    
  1279.                         }
  1280.                     
  1281.                     }
  1282.                     
  1284.                     $result["result"] = "OK";
  1285.                     
  1286.                 }
  1287.                 else
  1288.                 {
  1289.                     // Set error
  1290.                     $result["result"] = "ERROR";
  1291.                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain info is not a valid array or more than one domain info has returned!");;                        
  1292.                 }
  1295.             }
  1296.             else
  1297.             {
  1298.                 // Hata mesajini dondur
  1299.                 $result["result"] = "ERROR";
  1300.                 $result["error"] = $this->parseError($response);
  1301.             }
  1302.             
  1303.         }
  1304.         catch(Exception $ex)
  1305.         {
  1306.             $result["result"] = "ERROR";
  1307.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1308.         }
  1309.         
  1310.         return $result;
  1311.     }
  1312.     
  1315.     
  1316.     // Get domain details
  1317.     public function GetDetails($parameters)
  1318.     {
  1319.         $result = array();
  1320.         
  1321.         try
  1322.         {
  1323.             // SOAP method which is same as current function name called
  1324.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1326.             // Serialize as array
  1327.             $response = $this->objectToArray($response);
  1328.             
  1329.             // Check is there any error?
  1330.             if(!$this->hasError($response))
  1331.             {
  1332.                 $data = $response[key($response)];
  1335.                 // If DomainInfo a valid array
  1336.                 if(isset($data["DomainInfo"]) && is_array($data["DomainInfo"]))
  1337.                 {
  1338.                     // Parse domain info
  1339.                     $result["data"] = $this->parseDomainInfo($data["DomainInfo"]);
  1340.                     $result["result"] = "OK";
  1341.                     
  1342.                 }
  1343.                 else
  1344.                 {
  1345.                     // Set error
  1346.                     $result["result"] = "ERROR";
  1347.                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain info is not a valid array or more than one domain info has returned!");;                        
  1348.                 }
  1351.             }
  1352.             else
  1353.             {
  1354.                 // Hata mesajini dondur
  1355.                 $result["result"] = "ERROR";
  1356.                 $result["error"] = $this->parseError($response);
  1357.             }
  1358.             
  1359.         }
  1360.         catch(Exception $ex)
  1361.         {
  1362.             $result["result"] = "ERROR";
  1363.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1364.         }
  1365.         
  1366.         return $result;
  1367.     }
  1368.     
  1369.     
  1370.     
  1371.     
  1372.     
  1373.     // Modify name servers
  1374.     public function ModifyNameServer($parameters)
  1375.     {
  1376.         $result = array();
  1377.         
  1378.         try
  1379.         {
  1380.             // SOAP method which is same as current function name called
  1381.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1383.             // Serialize as array
  1384.             $response = $this->objectToArray($response);
  1385.             
  1386.             // Check is there any error?
  1387.             if(!$this->hasError($response))
  1388.             {
  1389.                 $result["data"] = array();
  1390.                 $result["data"]["NameServers"] = array();
  1391.                 $result["data"]["NameServers"] = $parameters["request"]["NameServerList"];
  1392.                 $result["result"] = "OK";
  1394.             }
  1395.             else
  1396.             {
  1397.                 // Hata mesajini dondur
  1398.                 $result["result"] = "ERROR";
  1399.                 $result["error"] = $this->parseError($response);
  1400.             }
  1401.             
  1402.         }
  1403.         catch(Exception $ex)
  1404.         {
  1405.             $result["result"] = "ERROR";
  1406.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1407.         }
  1408.         
  1409.         return $result;
  1410.     }   
  1411.     
  1412.    
  1414.     // Enable Theft Protection Lock
  1415.     public function EnableTheftProtectionLock($parameters)
  1416.     {
  1417.         $result = array();
  1418.         
  1419.         try
  1420.         {
  1421.             // SOAP method which is same as current function name called
  1422.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1424.             // Serialize as array
  1425.             $response = $this->objectToArray($response);
  1426.             
  1427.             // Check is there any error?
  1428.             if(!$this->hasError($response))
  1429.             {
  1430.                 $result["data"] = array();
  1431.                 $result["data"]["LockStatus"] = var_export(true, true);
  1432.                 $result["result"] = "OK";
  1434.             }
  1435.             else
  1436.             {
  1437.                 // Hata mesajini dondur
  1438.                 $result["result"] = "ERROR";
  1439.                 $result["error"] = $this->parseError($response);
  1440.             }
  1441.             
  1442.         }
  1443.         catch(Exception $ex)
  1444.         {
  1445.             $result["result"] = "ERROR";
  1446.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1447.         }
  1448.         
  1449.         return $result;
  1450.     }   
  1451.     
  1458.     // Disable Theft Protection Lock
  1459.     public function DisableTheftProtectionLock($parameters)
  1460.     {
  1461.         $result = array();
  1462.         
  1463.         try
  1464.         {
  1465.             // SOAP method which is same as current function name called
  1466.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1468.             // Serialize as array
  1469.             $response = $this->objectToArray($response);
  1470.             
  1471.             // Check is there any error?
  1472.             if(!$this->hasError($response))
  1473.             {
  1474.                 $result["data"] = array();
  1475.                 $result["data"]["LockStatus"] = var_export(false, true);
  1476.                 $result["result"] = "OK";
  1478.             }
  1479.             else
  1480.             {
  1481.                 // Hata mesajini dondur
  1482.                 $result["result"] = "ERROR";
  1483.                 $result["error"] = $this->parseError($response);
  1484.             }
  1485.             
  1486.         }
  1487.         catch(Exception $ex)
  1488.         {
  1489.             $result["result"] = "ERROR";
  1490.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1491.         }
  1492.         
  1493.         return $result;
  1494.     }   
  1495.     
  1496.     
  1500.     // Modify privacy protection status
  1501.     public function ModifyPrivacyProtectionStatus($parameters)
  1502.     {
  1503.         $result = array();
  1504.         
  1505.         try
  1506.         {
  1507.             // SOAP method which is same as current function name called
  1508.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1510.             // Serialize as array
  1511.             $response = $this->objectToArray($response);
  1512.             
  1513.             // Check is there any error?
  1514.             if(!$this->hasError($response))
  1515.             {
  1516.                 $result["data"] = array();
  1517.                 $result["data"]["PrivacyProtectionStatus"] = var_export($parameters["request"]["ProtectPrivacy"], true);
  1518.                 $result["result"] = "OK";
  1520.             }
  1521.             else
  1522.             {
  1523.                 // Hata mesajini dondur
  1524.                 $result["result"] = "ERROR";
  1525.                 $result["error"] = $this->parseError($response);
  1526.             }
  1527.             
  1528.         }
  1529.         catch(Exception $ex)
  1530.         {
  1531.             $result["result"] = "ERROR";
  1532.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1533.         }
  1534.         
  1535.         return $result;
  1536.     }   
  1537.     
  1541.     // CHILD NAMESERVER MANAGEMENT
  1542.     
  1543.     // Add Child Nameserver
  1544.     public function AddChildNameServer($parameters)
  1545.     {
  1546.         $result = array();
  1547.         
  1548.         try
  1549.         {
  1550.             // SOAP method which is same as current function name called
  1551.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1553.             // Serialize as array
  1554.             $response = $this->objectToArray($response);
  1555.             
  1556.             // Check is there any error?
  1557.             if(!$this->hasError($response))
  1558.             {
  1559.                 $result["data"] = array();
  1560.                 $result["data"]["NameServer"] = $parameters["request"]["ChildNameServer"];
  1561.                 $result["data"]["IPAdresses"] = array();
  1562.                 $result["data"]["IPAdresses"] = $parameters["request"]["IpAddressList"];
  1563.                 $result["result"] = "OK";
  1565.             }
  1566.             else
  1567.             {
  1568.                 // Hata mesajini dondur
  1569.                 $result["result"] = "ERROR";
  1570.                 $result["error"] = $this->parseError($response);
  1571.             }
  1572.             
  1573.         }
  1574.         catch(Exception $ex)
  1575.         {
  1576.             $result["result"] = "ERROR";
  1577.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1578.         }
  1579.         
  1580.         return $result;
  1581.     }   
  1582.     
  1583.     
  1585.     // Delete Child Nameserver
  1586.     public function DeleteChildNameServer($parameters)
  1587.     {
  1588.         $result = array();
  1589.         
  1590.         try
  1591.         {
  1592.             // SOAP method which is same as current function name called
  1593.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1595.             // Serialize as array
  1596.             $response = $this->objectToArray($response);
  1597.             
  1598.             // Check is there any error?
  1599.             if(!$this->hasError($response))
  1600.             {
  1601.                 $result["data"] = array();
  1602.                 $result["data"]["NameServer"] = $parameters["request"]["ChildNameServer"];
  1603.                 $result["result"] = "OK";
  1605.             }
  1606.             else
  1607.             {
  1608.                 // Hata mesajini dondur
  1609.                 $result["result"] = "ERROR";
  1610.                 $result["error"] = $this->parseError($response);
  1611.             }
  1612.             
  1613.         }
  1614.         catch(Exception $ex)
  1615.         {
  1616.             $result["result"] = "ERROR";
  1617.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1618.         }
  1619.         
  1620.         return $result;
  1621.     }   
  1625.     // Modify Child Nameserver
  1626.     public function ModifyChildNameServer($parameters)
  1627.     {
  1628.         $result = array();
  1630.         try
  1631.         {
  1632.             // SOAP method which is same as current function name called
  1633.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1635.             // Serialize as array
  1636.             $response = $this->objectToArray($response);
  1637.             
  1638.             // Check is there any error?
  1639.             if(!$this->hasError($response))
  1640.             {
  1641.                 $result["data"] = array();
  1642.                 $result["data"]["NameServer"] = $parameters["request"]["ChildNameServer"];
  1643.                 $result["data"]["IPAdresses"] = array();
  1644.                 $result["data"]["IPAdresses"] = $parameters["request"]["IpAddressList"];
  1645.                 $result["result"] = "OK";
  1647.             }
  1648.             else
  1649.             {
  1650.                 // Hata mesajini dondur
  1651.                 $result["result"] = "ERROR";
  1652.                 $result["error"] = $this->parseError($response);
  1653.             }
  1654.             
  1655.         }
  1656.         catch(Exception $ex)
  1657.         {
  1658.             $result["result"] = "ERROR";
  1659.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1660.         }
  1661.         
  1662.         return $result;
  1663.     }   
  1671.     // CONTACT MANAGEMENT
  1672.     
  1673.     // Get Contact
  1674.     public function GetContacts($parameters)
  1675.     {
  1676.         $result = array();
  1678.         try
  1679.         {
  1680.             // SOAP method which is same as current function name called
  1681.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1683.             // Serialize as array
  1684.             $response = $this->objectToArray($response);
  1685.             
  1686.             // Check is there any error?
  1687.             if(!$this->hasError($response))
  1688.             {
  1689.                 $data = $response[key($response)];
  1691.                 // If ContactInfo a valid array
  1692.                 if(isset($data["AdministrativeContact"]) && is_array($data["AdministrativeContact"]) && isset($data["TechnicalContact"]) && is_array($data["TechnicalContact"]) && isset($data["RegistrantContact"]) && is_array($data["RegistrantContact"]) && isset($data["BillingContact"]) && is_array($data["BillingContact"]))
  1693.                 {
  1694.                     // Parse domain info
  1695.                     $result["data"] = array();
  1696.                     $result["data"]["contacts"] = array();
  1697.                     $result["data"]["contacts"]["Administrative"] = $this->parseContactInfo($data["AdministrativeContact"]);
  1698.                     $result["data"]["contacts"]["Billing"] = $this->parseContactInfo($data["BillingContact"]);
  1699.                     $result["data"]["contacts"]["Registrant"] = $this->parseContactInfo($data["RegistrantContact"]);
  1700.                     $result["data"]["contacts"]["Technical"] = $this->parseContactInfo($data["TechnicalContact"]);
  1701.                     $result["result"] = "OK";
  1703.                 }
  1704.                 else
  1705.                 {
  1706.                     // Set error
  1707.                     $result["result"] = "ERROR";
  1708.                     $result["error"] = $this->setError("INVALID_CONTACT_INTO", "Invalid response received from server!", "Contact info is not a valid array or more than one contact info has returned!");;                     
  1709.                 }
  1711.             }
  1712.             else
  1713.             {
  1714.                 // Hata mesajini dondur
  1715.                 $result["result"] = "ERROR";
  1716.                 $result["error"] = $this->parseError($response);
  1717.             }
  1718.             
  1719.         }
  1720.         catch(Exception $ex)
  1721.         {
  1722.             $result["result"] = "ERROR";
  1723.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1724.         }
  1725.         
  1726.         return $result;
  1727.     }   
  1732.     // Save contact informations
  1733.     public function SaveContacts($parameters)
  1734.     {
  1735.         $result = array();
  1737.         try
  1738.         {
  1739.             // SOAP method which is same as current function name called
  1740.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1742.             // Serialize as array
  1743.             $response = $this->objectToArray($response);
  1744.             
  1745.             // Check is there any error?
  1746.             if(!$this->hasError($response))
  1747.             {
  1748.                 $data = $response[key($response)];
  1750.                 // If ContactInfo a valid array
  1751.                 if(1 == 1)
  1752.                 {
  1753.                     $result["result"] = "OK";
  1754.                 }
  1755.                 else
  1756.                 {
  1757.                     // Set error
  1758.                     $result["result"] = "ERROR";
  1759.                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain info is not a valid array or more than one domain info has returned!");;                        
  1760.                 }
  1762.             }
  1763.             else
  1764.             {
  1765.                 // Hata mesajini dondur
  1766.                 $result["result"] = "ERROR";
  1767.                 $result["error"] = $this->parseError($response);
  1768.             }
  1769.             
  1770.         }
  1771.         catch(Exception $ex)
  1772.         {
  1773.             $result["result"] = "ERROR";
  1774.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1775.         }
  1776.         
  1777.         return $result;
  1778.     }   
  1782.     // Start domain transfer
  1783.     public function Transfer($parameters)
  1784.     {
  1785.         $result = array();
  1787.         try
  1788.         {
  1789.             // SOAP method which is same as current function name called
  1790.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1792.             // Serialize as array
  1793.             $response = $this->objectToArray($response);
  1794.             
  1795.             // Check is there any error?
  1796.             if(!$this->hasError($response))
  1797.             {
  1798.                 $data = $response[key($response)];
  1800.                 // If DomainInfo a valid array
  1801.                 if(isset($data["DomainInfo"]) && is_array($data["DomainInfo"]))
  1802.                 {
  1803.                     // Parse domain info
  1804.                     $result["data"] = $this->parseDomainInfo($data["DomainInfo"]);
  1805.                     $result["result"] = "OK";
  1806.                     
  1807.                 }
  1808.                 else
  1809.                 {
  1810.                     // Set error
  1811.                     $result["result"] = "ERROR";
  1812.                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain info is not a valid array or more than one domain info has returned!");;                        
  1813.                 }
  1815.             }
  1816.             else
  1817.             {
  1818.                 // Hata mesajini dondur
  1819.                 $result["result"] = "ERROR";
  1820.                 $result["error"] = $this->parseError($response);
  1821.             }
  1822.             
  1823.         }
  1824.         catch(Exception $ex)
  1825.         {
  1826.             $result["result"] = "ERROR";
  1827.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1828.         }
  1829.         
  1830.         return $result;
  1831.     }   
  1835.     // Cancel domain transfer
  1836.     public function CancelTransfer($parameters)
  1837.     {
  1838.         $result = array();
  1840.         try
  1841.         {
  1842.             // SOAP method which is same as current function name called
  1843.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1845.             // Serialize as array
  1846.             $response = $this->objectToArray($response);
  1847.             
  1848.             // Check is there any error?
  1849.             if(!$this->hasError($response))
  1850.             {
  1851.                 // Parse domain info
  1852.                 $result["data"] = array();
  1853.                 $result["data"]["DomainName"] = $parameters["request"]["DomainName"];
  1854.                 $result["result"] = "OK";
  1855.             
  1857.             }
  1858.             else
  1859.             {
  1860.                 // Hata mesajini dondur
  1861.                 $result["result"] = "ERROR";
  1862.                 $result["error"] = $this->parseError($response);
  1863.             }
  1864.             
  1865.         }
  1866.         catch(Exception $ex)
  1867.         {
  1868.             $result["result"] = "ERROR";
  1869.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1870.         }
  1871.         
  1872.         return $result;
  1873.     }   
  1876.         // Cancel domain transfer
  1877.     public function CheckTransfer($parameters)
  1878.     {
  1879.         $result = array();
  1881.         try
  1882.         {
  1883.             // SOAP method which is same as current function name called
  1884.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1886.             // Serialize as array
  1887.             $response = $this->objectToArray($response);
  1888.             
  1889.             // Check is there any error?
  1890.             if(!$this->hasError($response))
  1891.             {
  1892.                 // Parse domain info
  1893.                 $result["data"] = array();
  1894.                 $result["data"]["DomainName"] = $parameters["request"]["DomainName"];
  1895.                 $result["result"] = "OK";
  1896.             
  1898.             }
  1899.             else
  1900.             {
  1901.                 // Hata mesajini dondur
  1902.                 $result["result"] = "ERROR";
  1903.                 $result["error"] = $this->parseError($response);
  1904.             }
  1905.             
  1906.         }
  1907.         catch(Exception $ex)
  1908.         {
  1909.             $result["result"] = "ERROR";
  1910.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1911.         }
  1912.         
  1913.         return $result;
  1914.     } 
  1915.     
  1916.     
  1919.     // Register domain with contact informations
  1920.     public function RegisterWithContactInfo($parameters)
  1921.     {
  1922.         $result = array();
  1924.         try
  1925.         {
  1926.             // SOAP method which is same as current function name called
  1927.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1929.             // Serialize as array
  1930.             $response = $this->objectToArray($response);
  1931.             
  1932.             // Check is there any error?
  1933.             if(!$this->hasError($response))
  1934.             {
  1935.                 $data = $response[key($response)];
  1937.                 // If DomainInfo a valid array
  1938.                 if(isset($data["DomainInfo"]) && is_array($data["DomainInfo"]))
  1939.                 {
  1940.                     // Parse domain info
  1941.                     $result["data"] = $this->parseDomainInfo($data["DomainInfo"]);
  1942.                     $result["result"] = "OK";
  1943.                     
  1944.                 }
  1945.                 else
  1946.                 {
  1947.                     // Set error
  1948.                     $result["result"] = "ERROR";
  1949.                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain info is not a valid array or more than one domain info has returned!");;                        
  1950.                 }
  1952.             }
  1953.             else
  1954.             {
  1955.                 // Hata mesajini dondur
  1956.                 $result["result"] = "ERROR";
  1957.                 $result["error"] = $this->parseError($response);
  1958.             }
  1959.             
  1960.         }
  1961.         catch(Exception $ex)
  1962.         {
  1963.             $result["result"] = "ERROR";
  1964.             $result["error"] = $this->parseError($this->objectToArray($ex));
  1965.         }
  1966.         
  1967.         return $result;
  1968.     }   
  1973.     // Renew domain
  1974.     public function Renew($parameters)
  1975.     {
  1976.         $result = array();
  1978.         try
  1979.         {
  1980.             // SOAP method which is same as current function name called
  1981.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  1983.             // Serialize as array
  1984.             $response = $this->objectToArray($response);
  1985.             
  1986.             // Check is there any error?
  1987.             if(!$this->hasError($response))
  1988.             {
  1989.                 $data = $response[key($response)];
  1991.                 $result["data"] = array();
  1992.                 $result["data"]["ExpirationDate"] = "";
  1994.                 if(isset($data["ExpirationDate"]))
  1995.                 {
  1996.                     $result["data"]["ExpirationDate"] = $data["ExpirationDate"];
  1997.                 }
  1999.                 $result["result"] = "OK";
  2000.             
  2002.             }
  2003.             else
  2004.             {
  2005.                 // Hata mesajini dondur
  2006.                 $result["result"] = "ERROR";
  2007.                 $result["error"] = $this->parseError($response);
  2008.             }
  2009.             
  2010.         }
  2011.         catch(Exception $ex)
  2012.         {
  2013.             $result["result"] = "ERROR";
  2014.             $result["error"] = $this->parseError($this->objectToArray($ex));
  2015.         }
  2016.         
  2017.         return $result;
  2018.     }   
  2027.     // Delete domain
  2028.     public function Delete($parameters)
  2029.     {
  2030.         $result = array();
  2032.         try
  2033.         {
  2034.             // SOAP method which is same as current function name called
  2035.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  2037.             // Serialize as array
  2038.             $response = $this->objectToArray($response);
  2039.             
  2040.             // Check is there any error?
  2041.             if(!$this->hasError($response))
  2042.             {
  2043.                 $result["result"] = "OK";
  2044.             }
  2045.             else
  2046.             {
  2047.                 // Hata mesajini dondur
  2048.                 $result["result"] = "ERROR";
  2049.                 $result["error"] = $this->parseError($response);
  2050.             }
  2051.             
  2052.         }
  2053.         catch(Exception $ex)
  2054.         {
  2055.             $result["result"] = "ERROR";
  2056.             $result["error"] = $this->parseError($this->objectToArray($ex));
  2057.         }
  2058.         
  2059.         return $result;
  2060.     }   
  2070.     
  2071.     // Sync domain details
  2072.     public function SyncFromRegistry($parameters)
  2073.     {
  2074.         $result = array();
  2075.         
  2076.         try
  2077.         {
  2078.             // SOAP method which is same as current function name called
  2079.             $response = $this->service->__soapCall(__FUNCTION__, array($parameters));
  2081.             // Serialize as array
  2082.             $response = $this->objectToArray($response);
  2083.             
  2084.             // Check is there any error?
  2085.             if(!$this->hasError($response))
  2086.             {
  2087.                 $data = $response[key($response)];
  2089.                 // If DomainInfo a valid array
  2090.                 if(isset($data["DomainInfo"]) && is_array($data["DomainInfo"]))
  2091.                 {
  2092.                     // Parse domain info
  2093.                     $result["data"] = $this->parseDomainInfo($data["DomainInfo"]);
  2094.                     $result["result"] = "OK";
  2095.                     
  2096.                 }
  2097.                 else
  2098.                 {
  2099.                     // Set error
  2100.                     $result["result"] = "ERROR";
  2101.                     $result["error"] = $this->setError("INVALID_DOMAIN_LIST", "Invalid response received from server!", "Domain info is not a valid array or more than one domain info has returned!");;                        
  2102.                 }
  2104.             }
  2105.             else
  2106.             {
  2107.                 // Hata mesajini dondur
  2108.                 $result["result"] = "ERROR";
  2109.                 $result["error"] = $this->parseError($response);
  2110.             }
  2111.             
  2112.         }
  2113.         catch(Exception $ex)
  2114.         {
  2115.             $result["result"] = "ERROR";
  2116.             $result["error"] = $this->parseError($this->objectToArray($ex));
  2117.         }
  2118.         
  2119.         return $result;
  2120.     }
  2121.     
  2122.     
  2123.     
  2124. }
  2135. class DomainNameAPI_PHPLibrary
  2136. {
  2137.     // VARIABLES
  2138.     public $_VERSION_ = "1.2";
  2139.     private $_USERDATA_USERNAME = "ownername";
  2140.     private $_USERDATA_PASSWORD = "ownerpass";
  2141.     //private $_URL_SERVICE = "http://api-ote.domainnameapi.com/DomainAPI.svc";
  2142.     private $_URL_SERVICE = "http://api.domainnameapi.com/DomainAPI.svc";
  2143.    //  https://api.domainnameapi.com/DomainAPI.svc
  2144.     private $_CONNECTION_METHOD = "APIConnection_SOAP";
  2145.     private $_VERSION = "1.0.0.0";
  2146.     private $con = null;
  2147.     private $_useTestMode = true;
  2148.     private $_useCaching = false;
  2149.     private $_cache = array();
  2151.     public $__REQUEST = array();
  2152.     public $__RESPONSE = array();
  2153.         
  2154.     // CONSTRUCTORS
  2155.     // Default constructors
  2156.     function __construct() 
  2157.     { 
  2158.         $this->useTestMode(true);
  2159.         $this->useCaching(false);
  2160.         //$this->setConnectionMethod("Auto"); //Old value edited by Kadjo Famian
  2161.         $this->setConnectionMethod("SOAP"); 
  2162.     }
  2163.     function DomainNameAPI_PHPLibrary() 
  2164.     {
  2165.         $this->useTestMode(true);
  2166.         $this->useCaching(false);
  2167.         //$this->setConnectionMethod("Auto"); //Old value edited by Kadjo Famian
  2168.         $this->setConnectionMethod("SOAP");
  2169.     }
  2170.     
  2171.     // METHODS  
  2172.     
  2173.     // USE TEST PLATFORM OR REAL PLATFORM
  2174.     // if value equals false, use real platform, otherwise use test platform
  2175.     public function useTestMode($value)
  2176.     { 
  2177.         if($value === false)
  2178.         {
  2179.             // REAL MODE
  2180.             $this->_useTestMode = false;
  2181.             $this->_URL_SERVICE = "http://api.domainnameapi.com/domainapi.svc";
  2182.         }
  2183.         else
  2184.         {
  2185.             // TEST MODE
  2186.             $this->_useTestMode = true;
  2187.             $this->_URL_SERVICE = "http://api.domainnameapi.com/DomainAPI.svc";
  2188.             $this->_USERDATA_USERNAME = "ownername";
  2189.             $this->_USERDATA_PASSWORD = "ownerpass";
  2190.         }
  2191.         
  2192.         $this->setConnectionMethod("Auto");
  2193.     }
  2195.     // CACHING 
  2196.     
  2197.     // Caching will be enabled or not
  2198.     public function useCaching($value)
  2199.     { 
  2200.         if($value === true)
  2201.         { $this->_useCaching = true; }
  2202.         else
  2203.         { $this->_useCaching = false; }
  2205.     }
  2206.     
  2207.     // Remove domain's value from cache
  2208.     public function removeDomainFromCache($DomainName)
  2209.     {
  2210.         if(isset($this->_cache[$DomainName]))
  2211.         { unset($this->_cache[$DomainName]); }
  2212.     }
  2213.     
  2214.     // Get used mode? TEST => true, REAL => false
  2215.     public function isTestMode() 
  2216.     { return ($this->_useTestMode === false) ? false : true; }
  2217.     
  2218.     // SET Username and Password
  2219.     public function setUser($UserName, $Password)
  2220.     {
  2221.         $this->_USERDATA_USERNAME = $UserName;
  2222.         $this->_USERDATA_PASSWORD = $Password;
  2223.     }
  2224.     
  2225.     // Get connection method
  2226.     public function getConnectionMethod()
  2227.     {
  2228.         return $this->_CONNECTION_METHOD;
  2229.     }
  2230.     
  2231.     // Set connection method
  2232.     public function setConnectionMethod($Method)
  2233.     {
  2234.         switch(strtoupper(trim($Method)))
  2235.         {
  2236.               case "SOAP":
  2237.                 $this->_CONNECTION_METHOD = "APIConnection_SOAP";
  2238.                 
  2239.                 $this->con = new APIConnection_SOAP($this->_URL_SERVICE);
  2240.                 break;
  2241.                 
  2242.             case "CURL";
  2243.                 $this->_CONNECTION_METHOD = "APIConnection_CURL";
  2244.                 
  2245.                 $this->con = new APIConnection_CURL($this->_URL_SERVICE);
  2246.                 break;
  2247.                 
  2248.             default:
  2249.                 if(class_exists("SoapClient")){
  2250.                     $this->_CONNECTION_METHOD = "APIConnection_SOAP";
  2251.                     $this->con = new APIConnection_SOAP($this->_URL_SERVICE);
  2252.                 }
  2253.                 elseif(function_exists("curl_init")){ 
  2254.                     $this->_CONNECTION_METHOD = "APIConnection_CURL";
  2255.                     $this->con = new APIConnection_CURL($this->_URL_SERVICE);
  2256.                 }
  2257.                 else
  2258.                 { 
  2259.                     // DUZELT
  2260.                     $this->_CONNECTION_METHOD = "ALL_OF_CONNECTION_METHODS_NOT_AVAILABLE";
  2261.                     
  2262.                     $this->con = new ALL_OF_CONNECTION_METHODS_NOT_AVAILABLE($this->_URL_SERVICE);
  2263.                 }
  2264.                 break;
  2265.         }
  2267.         // Prepare connection
  2268.         //$this->con = new $this->_CONNECTION_METHOD($this->_URL_SERVICE);
  2269.         
  2270.     }
  2271.     
  2272.     
  2273.     
  2274.     
  2275.     
  2276.     // API METHODS
  2277.     
  2278.     // Check domain is avaliable? Ex: ('example1', 'example2'), ('com', 'net', 'org')
  2279.     public function CheckAvailability($Domains, $TLDs, $Period , $Command)
  2280.     {
  2281.         $parameters = array(
  2282.             "request" => array(
  2283.                 "Password" => $this->_USERDATA_PASSWORD,
  2284.                 "UserName" => $this->_USERDATA_USERNAME,
  2285.                 "DomainNameList" => $Domains,
  2286.                 "TldList" => $TLDs,
  2287.                 "Period" =>  $Period, 
  2288.                 "Commad" => $Command
  2289.             )
  2290.         );
  2291.         
  2292.         // Check availability via already prepared connection
  2293.         $response = $this->con->CheckAvailability($parameters);
  2295.         // Log last request and response
  2296.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2298.         return $response;
  2299.     }
  2300.     
  2301.     
  2302.     
  2303.     
  2304.     // Get domain details
  2305.     public function GetList()
  2306.     {
  2307.         $parameters = array(
  2308.             "request" => array(
  2309.                 "Password" => $this->_USERDATA_PASSWORD,
  2310.                 "UserName" => $this->_USERDATA_USERNAME
  2311.             )
  2312.         );
  2313.         
  2314.         // Get domain id via already prepared connection
  2315.         $response = $this->con->GetList($parameters);
  2317.         // Log last request and response
  2318.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2320.         return $response;
  2321.     }
  2322.     
  2323.     
  2324.     // Get domain details
  2325.     public function GetDetails($DomainName)
  2326.     {
  2327.     
  2328.         // If caching enabled  
  2329.         if($this->_useCaching == true)
  2330.         {
  2331.             
  2332.             // If is there any cached value for this domain?
  2333.             if(isset($this->_cache[$DomainName]["result"]))
  2334.             {
  2335.                 // Return cached value
  2336.                 $result = $this->_cache[$DomainName]["result"];
  2337.                 $result["fromCache"] = true;
  2339.                 return $result;
  2340.             }
  2341.             
  2342.         }
  2343.         
  2344.         $parameters = array(
  2345.             "request" => array(
  2346.                 "Password" => $this->_USERDATA_PASSWORD,
  2347.                 "UserName" => $this->_USERDATA_USERNAME,
  2348.                 "DomainName" => $DomainName
  2349.             )
  2350.         );
  2351.         
  2352.         // Get domain id via already prepared connection
  2353.         $response = $this->con->GetDetails($parameters);
  2355.         // Log last request and response
  2356.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2358.         // If caching enabled  
  2359.         if($this->_useCaching == true)
  2360.         {
  2361.             $this->_cache[$DomainName]["result"] = $response;
  2362.             $this->_cache[$DomainName]["date"] = date("Y-m-d H:i:s");
  2363.         }
  2364.         
  2365.         return $response;
  2366.     }
  2367.     
  2368.     
  2369.     
  2370.     
  2371.     // Modify nameservers
  2372.     public function ModifyNameServer($DomainName, $NameServers)
  2373.     {
  2374.         $parameters = array(
  2375.             "request" => array(
  2376.                 "Password" => $this->_USERDATA_PASSWORD,
  2377.                 "UserName" => $this->_USERDATA_USERNAME,
  2378.                 "DomainName" => $DomainName,
  2379.                 "NameServerList" => $NameServers
  2380.             )
  2381.         );
  2382.         
  2383.         // We will modify domain, so remove it from cache
  2384.         $this->removeDomainFromCache($DomainName);
  2385.         
  2386.         // Check availability via already prepared connection
  2387.         $response = $this->con->ModifyNameServer($parameters);
  2389.         // Log last request and response
  2390.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2392.         return $response;
  2393.     }
  2394.     
  2397.     // Enable Theft Protection Lock
  2398.     public function EnableTheftProtectionLock($DomainName)
  2399.     {
  2400.         $parameters = array(
  2401.             "request" => array(
  2402.                 "Password" => $this->_USERDATA_PASSWORD,
  2403.                 "UserName" => $this->_USERDATA_USERNAME,
  2404.                 "DomainName" => $DomainName
  2405.             )
  2406.         );
  2407.         
  2408.         // We will modify domain, so remove it from cache
  2409.         $this->removeDomainFromCache($DomainName);
  2410.         
  2411.         // Enable theft protection lock via already prepared connection
  2412.         $response = $this->con->EnableTheftProtectionLock($parameters);
  2414.         // Log last request and response
  2415.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2417.         return $response;
  2418.     }
  2419.             
  2421.     // Disable Theft Protection Lock
  2422.     public function DisableTheftProtectionLock($DomainName)
  2423.     {
  2424.         $parameters = array(
  2425.             "request" => array(
  2426.                 "Password" => $this->_USERDATA_PASSWORD,
  2427.                 "UserName" => $this->_USERDATA_USERNAME,
  2428.                 "DomainName" => $DomainName
  2429.             )
  2430.         );
  2431.         
  2432.         // We will modify domain, so remove it from cache
  2433.         $this->removeDomainFromCache($DomainName);
  2434.         
  2435.         // Disable theft protection lock via already prepared connection
  2436.         $response = $this->con->DisableTheftProtectionLock($parameters);
  2438.         // Log last request and response
  2439.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2441.         return $response;
  2442.     }
  2443.     
  2447.     // CHILD NAMESERVER MANAGEMENT
  2448.     
  2449.     // Add Child Nameserver
  2450.     public function AddChildNameServer($DomainName, $NameServer, $IPAdresses)
  2451.     {
  2452.         $parameters = array(
  2453.             "request" => array(
  2454.                 "Password" => $this->_USERDATA_PASSWORD,
  2455.                 "UserName" => $this->_USERDATA_USERNAME,
  2456.                 "DomainName" => $DomainName,
  2457.                 "ChildNameServer" => $NameServer,
  2458.                 "IpAddressList" => $IPAdresses
  2459.             )
  2460.         );
  2461.         
  2462.         // We will modify domain, so remove it from cache
  2463.         $this->removeDomainFromCache($DomainName);
  2464.         
  2465.         // Add child nameserver via already prepared connection
  2466.         $response = $this->con->AddChildNameServer($parameters);
  2468.         // Log last request and response
  2469.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2471.         return $response;
  2472.     }
  2473.     
  2474.     
  2475.     
  2476.     // Delete Child Nameserver
  2477.     public function DeleteChildNameServer($DomainName, $NameServer)
  2478.     {
  2479.         $parameters = array(
  2480.             "request" => array(
  2481.                 "Password" => $this->_USERDATA_PASSWORD,
  2482.                 "UserName" => $this->_USERDATA_USERNAME,
  2483.                 "DomainName" => $DomainName,
  2484.                 "ChildNameServer" => $NameServer
  2485.             )
  2486.         );
  2487.         
  2488.         // We will modify domain, so remove it from cache
  2489.         $this->removeDomainFromCache($DomainName);
  2490.         
  2491.         // Delete child nameserver via already prepared connection
  2492.         $response = $this->con->DeleteChildNameServer($parameters);
  2494.         // Log last request and response
  2495.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2497.         return $response;
  2498.     }
  2499.     
  2500.     
  2501.     // Modify Child Nameserver
  2502.     public function ModifyChildNameServer($DomainName, $NameServer, $IPAdresses)
  2503.     {
  2504.         $parameters = array(
  2505.             "request" => array(
  2506.                 "Password" => $this->_USERDATA_PASSWORD,
  2507.                 "UserName" => $this->_USERDATA_USERNAME,
  2508.                 "DomainName" => $DomainName,
  2509.                 "ChildNameServer" => $NameServer,
  2510.                 "IpAddressList" => $IPAdresses
  2511.             )
  2512.         );
  2513.         
  2514.         // We will modify domain, so remove it from cache
  2515.         $this->removeDomainFromCache($DomainName);
  2516.         
  2517.         // Add child nameserver via already prepared connection
  2518.         $response = $this->con->ModifyChildNameServer($parameters);
  2520.         // Log last request and response
  2521.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2523.         return $response;
  2524.     }
  2525.     
  2526.     
  2527.     
  2528.     
  2529.     // CONTACT MANAGEMENT
  2530.     
  2531.     // Get Domain Contact informations
  2532.     public function GetContacts($DomainName)
  2533.     {
  2534.         $parameters = array(
  2535.             "request" => array(
  2536.                 "Password" => $this->_USERDATA_PASSWORD,
  2537.                 "UserName" => $this->_USERDATA_USERNAME,
  2538.                 "DomainName" => $DomainName
  2539.             )
  2540.         );
  2541.         
  2542.         // Get Domain Contact informations via already prepared connection
  2543.         $response = $this->con->GetContacts($parameters);
  2545.         // Log last request and response
  2546.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2548.         return $response;
  2549.     }
  2550.     
  2551.     
  2552.     
  2553.     // Set domain cantacts
  2554.     public function SaveContacts($DomainName, $Contacts)
  2555.     {
  2556.         $parameters = array(
  2557.             "request" => array(
  2558.                 "Password" => $this->_USERDATA_PASSWORD,
  2559.                 "UserName" => $this->_USERDATA_USERNAME,
  2560.                 "DomainName" => $DomainName,
  2561.                 "AdministrativeContact" => $Contacts["Administrative"],
  2562.                 "BillingContact" => $Contacts["Billing"],
  2563.                 "TechnicalContact" => $Contacts["Technical"],
  2564.                 "RegistrantContact" => $Contacts["Registrant"]
  2565.             )
  2566.         );
  2567.         
  2568.         // We will modify domain, so remove it from cache
  2569.         $this->removeDomainFromCache($DomainName);
  2570.         
  2571.         // Register domain via already prepared connection
  2572.         $response = $this->con->SaveContacts($parameters);
  2574.         // Log last request and response
  2575.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2577.         return $response;
  2578.     }
  2579.     
  2580.     
  2581.     
  2582.     // DOMAIN TRANSFER (INCOMING DOMAIN)
  2583.     
  2584.     // Start domain transfer (Incoming domain)
  2585.     public function Transfer($DomainName, $AuthCode)
  2586.     {
  2587.         $parameters = array(
  2588.             "request" => array(
  2589.                 "Password" => $this->_USERDATA_PASSWORD,
  2590.                 "UserName" => $this->_USERDATA_USERNAME,
  2591.                 "DomainName" => $DomainName,
  2592.                 "AuthCode" => $AuthCode
  2593.             )
  2594.         );
  2595.         
  2596.         // We will modify domain, so remove it from cache
  2597.         $this->removeDomainFromCache($DomainName);
  2598.         
  2599.         // Start domain transfer via already prepared connection
  2600.         $response = $this->con->Transfer($parameters);
  2602.         // Log last request and response
  2603.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2605.         return $response;
  2606.     }
  2607.     
  2610.     
  2611.     // Cancel domain transfer (Incoming domain)
  2612.     public function CancelTransfer($DomainName)
  2613.     {
  2614.         $parameters = array(
  2615.             "request" => array(
  2616.                 "Password" => $this->_USERDATA_PASSWORD,
  2617.                 "UserName" => $this->_USERDATA_USERNAME,
  2618.                 "DomainName" => $DomainName
  2619.             )
  2620.         );
  2621.         
  2622.         // We will modify domain, so remove it from cache
  2623.         $this->removeDomainFromCache($DomainName);
  2624.         
  2625.         // Cancel domain transfer via already prepared connection
  2626.         $response = $this->con->CancelTransfer($parameters);
  2628.         // Log last request and response
  2629.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2631.         return $response;
  2632.     }
  2633.     
  2634.     
  2635.     // Cancel domain transfer (Incoming domain)
  2636.     public function CheckTransfer($DomainName)
  2637.     {
  2638.         $parameters = array(
  2639.             "request" => array(
  2640.                 "Password" => $this->_USERDATA_PASSWORD,
  2641.                 "UserName" => $this->_USERDATA_USERNAME,
  2642.                 "DomainName" => $DomainName
  2643.             )
  2644.         );
  2645.         
  2646.         // We will modify domain, so remove it from cache
  2647.         $this->removeDomainFromCache($DomainName);
  2648.         
  2649.         // Cancel domain transfer via already prepared connection
  2650.         $response = $this->con->CheckTransfer($parameters);
  2652.         // Log last request and response
  2653.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2655.         return $response;
  2656.     }
  2658.     // Renew domain
  2659.     public function Renew($DomainName, $Period)
  2660.     {
  2661.         $parameters = array(
  2662.             "request" => array(
  2663.                 "Password" => $this->_USERDATA_PASSWORD,
  2664.                 "UserName" => $this->_USERDATA_USERNAME,
  2665.                 "DomainName" => $DomainName,
  2666.                 "Period" => $Period
  2667.             )
  2668.         );
  2669.         
  2670.         // We will modify domain, so remove it from cache
  2671.         $this->removeDomainFromCache($DomainName);
  2672.         
  2673.         // Renew domain via already prepared connection
  2674.         $response = $this->con->Renew($parameters);
  2676.         // Log last request and response
  2677.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2679.         return $response;
  2680.     }
  2681.     
  2682.     
  2683.     
  2684.     // Register domain with contact informations
  2685.     public function RegisterWithContactInfo($DomainName, $Period, $Contacts, $NameServers = array("dns.domainnameapi.com", "web.domainnameapi.com"), $TheftProtectionLock = true, $PrivacyProtection = false)
  2686.     {
  2687.         $parameters = array(
  2688.             "request" => array(
  2689.                 "Password" => $this->_USERDATA_PASSWORD,
  2690.                 "UserName" => $this->_USERDATA_USERNAME,
  2691.                 "DomainName" => $DomainName,
  2692.                 "Period" => $Period,
  2693.                 "NameServerList" => $NameServers,
  2694.                 "LockStatus" => $TheftProtectionLock,
  2695.                 "PrivacyProtectionStatus" => $PrivacyProtection,
  2696.                 "AdministrativeContact" => $Contacts["Administrative"],
  2697.                 "BillingContact" => $Contacts["Billing"],
  2698.                 "TechnicalContact" => $Contacts["Technical"],
  2699.                 "RegistrantContact" => $Contacts["Registrant"]
  2700.             )
  2701.         );
  2702.         
  2703.         // We will modify domain, so remove it from cache
  2704.         $this->removeDomainFromCache($DomainName);
  2705.         
  2706.         // Register domain via already prepared connection
  2707.         $response = $this->con->RegisterWithContactInfo($parameters);
  2709.         // Log last request and response
  2710.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2712.         return $response;
  2713.     }
  2714.     
  2716.     // Modify privacy protection status of domain
  2717.     public function ModifyPrivacyProtectionStatus($DomainName, $Status, $Reason = "Owner request")
  2718.     {
  2719.         if(trim($Reason) == "") { $Reason = "Owner request"; }
  2720.         
  2721.         $parameters = array(
  2722.             "request" => array(
  2723.                 "Password" => $this->_USERDATA_PASSWORD,
  2724.                 "UserName" => $this->_USERDATA_USERNAME,
  2725.                 "DomainName" => $DomainName,
  2726.                 "ProtectPrivacy" => $Status,
  2727.                 "Reason" => $Reason
  2728.             )
  2729.         );
  2730.         
  2731.         // We will modify domain, so remove it from cache
  2732.         $this->removeDomainFromCache($DomainName);
  2733.         
  2734.         // Modify privacy protection status of domain via already prepared connection
  2735.         $response = $this->con->ModifyPrivacyProtectionStatus($parameters);
  2737.         // Log last request and response
  2738.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2740.         return $response;
  2741.     }
  2742.     
  2743.     
  2744.     // Sync domain
  2745.     public function SyncFromRegistry($DomainName)
  2746.     {
  2747.         $parameters = array(
  2748.             "request" => array(
  2749.                 "Password" => $this->_USERDATA_PASSWORD,
  2750.                 "UserName" => $this->_USERDATA_USERNAME,
  2751.                 "DomainName" => $DomainName
  2752.             )
  2753.         );
  2754.         
  2755.         // We will modify domain, so remove it from cache
  2756.         $this->removeDomainFromCache($DomainName);
  2757.         
  2758.         // Sync domain via already prepared connection
  2759.         $response = $this->con->SyncFromRegistry($parameters);
  2761.         // Log last request and response
  2762.         $this->__REQUEST = $parameters; $this->__RESPONSE = $response;
  2764.         return $response;
  2765.     }
  2766.     
  2767.     
  2768. }