src/Controller/HostingController.php line 510

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