src/Service/Xero/ContactService.php line 25

Open in your IDE?
  1. <?php
  2. // src/Service/UserService.php
  3. namespace App\Service\Xero;
  5. use App\Entity\FilmProject;
  6. use App\Entity\OrderDetails;
  7. use App\Entity\User;
  8. use App\Authenticator\XeroAuthenticator;
  9. use App\Repository\UserRepository;
  10. use App\Service\Xero\XeroService;
  11. use Exception;
  12. use XeroAPI\XeroPHP\AccountingObjectSerializer;
  13. use XeroAPI\XeroPHP\Models\Accounting\Contact;
  14. use XeroAPI\XeroPHP\Models\Accounting\ContactPerson;
  15. use XeroAPI\XeroPHP\Models\Accounting\Contacts;
  16. use XeroAPI\XeroPHP\ApiException;
  17. use XeroAPI\XeroPHP\Models\Accounting\Address;
  19. final class ContactService extends XeroService
  20. {
  21.     private $userRepository;
  23.     public function __construct(XeroAuthenticator $xeroAuthenticator, UserRepository $userRepository)
  24.     {        
  25.         parent::__construct($xeroAuthenticator);
  26.         $this->userRepository = $userRepository;
  27.     }
  29.     /**
  30.      * Create Xero contact 
  31.      *
  32.      * @param User $user
  33.      * @return string
  34.      */
  35.     public function createContact(User $user): string 
  36.     {
  37.          // Check if contact is already registered in the system
  38.         $xeroID = $this->getContactByUser($user);
  39.         if (!empty($xeroID)) {
  40.             return $xeroID;
  41.         }
  43.         $contact = new Contact;
  44.         $contact->setName($user->getFirstName() . ' ' . $user->getLastName())
  45.             ->setFirstName($user->getFirstName())
  46.             ->setLastName($user->getLastName())
  47.             ->setEmailAddress($user->getEmail())
  48.         ;
  50.         if ($user->getUserAddress()) {
  51.             $userAddress = $user->getUserAddress();
  52.             
  53.             $address = new Address();
  54.             $address->setAddressType(Address::ADDRESS_TYPE_STREET);
  55.             if ($userAddress->getStreet()) $address->setAddressLine1($userAddress->getStreet());
  56.             if ($userAddress->getCity()) $address->setCity($userAddress->getCity());
  57.             if ($userAddress->getState()) $address->setRegion($userAddress->getState());
  58.             if ($userAddress->getPostcode()) $address->setPostalCode($userAddress->getPostcode());
  59.             if ($userAddress->getCountry()) $address->setCountry($userAddress->getCountry());
  61.             $arr_addresses = [];
  62.             array_push($arr_addresses, $address);
  63.             $contact->setAddresses($arr_addresses);
  64.         }
  66.         $arr_contacts = [];
  67.         array_push($arr_contacts, $contact);
  69.         $contacts = new Contacts;
  70.         $contacts->setContacts($arr_contacts);
  72.         try {
  73.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  74.         } catch(ApiException $e) {
  75.             $this->throwXeroException($e);
  76.         } 
  78.         if ($apiResponse[0]['has_validation_errors']) {
  79.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  80.         }
  82.         return $apiResponse[0]['contact_id'];
  83.     }
  85.     public function findContactByprojectName(FilmProject $filmProject): string | null
  86.     {
  87.         $fullName = $filmProject->getTitle();
  89.         /** This represents paramater needed for Xero getContacts */
  90.         $modifiedSince = new \DateTime('2010-01-01');
  91.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  92.         $order = "Name ASC";
  93.         $page = 1;
  94.         $searchTerm = $fullName; // since xero has contactName as its unique name
  95.         $includeArchived = true;
  96.         $summaryOnly = true;
  98.         try {
  99.             $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  100.         } catch(ApiException $e) {
  101.         dd($e);
  102.             $this->throwXeroException($e);
  103.         } 
  105.         if(count($contacts) > 0) {
  106.             return $contacts[0]['contact_id'];
  107.         }
  109.         return null;
  110.     }
  112.     /**
  113.      * Create Xero contact 
  114.      *
  115.      * @param User $user
  116.      * @return string
  117.      */
  118.     public function createContactByProjectName(FilmProject $filmProject): string 
  119.     {
  120.         $contact = new Contact;
  122.         $user = $filmProject->getOwner();
  124.         $contact->setName($filmProject->getTitle()) // Unique name here
  125.             ->setFirstName($user->getFirstName())
  126.             ->setLastName($user->getLastName())
  127.             ->setEmailAddress($user->getEmail())
  128.         ;
  130.         if ($user->getUserAddress()) {
  131.             $userAddress = $user->getUserAddress();
  132.             
  133.             $address = new Address();
  134.             $address->setAddressType(Address::ADDRESS_TYPE_STREET);
  135.             if ($userAddress->getStreet()) $address->setAddressLine1($userAddress->getStreet());
  136.             if ($userAddress->getCity()) $address->setCity($userAddress->getCity());
  137.             if ($userAddress->getState()) $address->setRegion($userAddress->getState());
  138.             if ($userAddress->getPostcode()) $address->setPostalCode($userAddress->getPostcode());
  139.             if ($userAddress->getCountry()) $address->setCountry($userAddress->getCountry());
  141.             $arr_addresses = [];
  142.             array_push($arr_addresses, $address);
  143.             $contact->setAddresses($arr_addresses);
  144.         }
  146.         $arr_contacts = [];
  147.         array_push($arr_contacts, $contact);
  149.         $contacts = new Contacts;
  150.         $contacts->setContacts($arr_contacts);
  152.         try {
  153.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  154.         } catch(ApiException $e) {
  155.             $this->throwXeroException($e);
  156.         } 
  158.         if ($apiResponse[0]['has_validation_errors']) {
  159.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  160.         }
  162.         return $apiResponse[0]['contact_id'];
  163.     }
  165.     /**
  166.      * Update contact
  167.      *
  168.      * @param User $user
  169.      * @return void
  170.      */
  171.     public function updateContact(User $user)
  172.     {
  173.         $userInformation = $user->getUserInformation();
  174.         $userAddress = $user->getUserAddress();
  175.         $xeroContactId = $userInformation->getXeroId();
  177.         $arr_addresses = [];
  178.         $address = (new Address())
  179.             ->setAddressType(Address::ADDRESS_TYPE_STREET)
  180.             ->setAddressLine1($userAddress->getStreet())
  181.             ->setCity($userAddress->getCity())
  182.             ->setPostalCode($userAddress->getPostcode())
  183.         ;
  184.         array_push($arr_addresses, $address);
  186.         $contact = new Contact();
  187.         $contact
  188.             ->setName($user->getFirstName() . ' ' . $user->getLastName())
  189.             ->setFirstName($user->getFirstName())
  190.             ->setLastName($user->getLastName())
  191.             ->setContactID($xeroContactId)
  192.             ->setAddresses($arr_addresses)
  193.         ;
  195.         $arr_contacts = [];
  196.         array_push($arr_contacts, $contact);
  198.         $contacts = new Contacts;
  199.         $contacts->setContacts($arr_contacts);
  201.         try {
  202.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  203.         } catch(ApiException $e) {
  204.             $this->throwXeroException($e);
  205.         } 
  207.         if ($apiResponse[0]['has_validation_errors']) {
  208.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  209.         }
  210.         
  211.         return $apiResponse[0]['contact_id'];
  212.     }
  214.     /**
  215.      * Get contacts by email
  216.      *
  217.      * @param [type] $fullname
  218.      * @return string
  219.      */
  220.     public function getContactByUser(User $user): ?string
  221.     {
  222.         $fullName = $user->getFirstName() . ' ' . $user->getLastName();
  224.         /** This represents paramater needed for Xero getContacts */
  225.         $modifiedSince = new \DateTime('2010-01-01');
  226.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  227.         $order = "Name ASC";
  228.         $page = 1;
  229.         $searchTerm = $fullName; // since xero has contactName as its unique name
  230.         $includeArchived = true;
  231.         $summaryOnly = true;
  233.         $isExistContact = false;
  234.         try {
  235.             $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  236.         } catch(ApiException $e) {
  237.             $this->throwXeroException($e);
  238.         } 
  240.         if(count($contacts) > 0) $isExistContact = true;
  241.         foreach ($contacts as $contact) {
  242.             if (strtolower($contact['email_address']) == strtolower($user->getEmailAddress())) {
  243.                 return $contact['contact_id'];
  244.             }
  245.         }
  247.         if ($isExistContact) { // If contact found but no email address found in that contact, add it as an additional person
  248.             $xeroContactId = $contacts[0]['contact_id']; // Get the first contact details ID
  249.             return $this->updateContactWithAdditionalPersonDetails($user, $xeroContactId);
  250.         }
  252.         return null;
  253.     }
  255.     /**
  256.      * Get contacts by email
  257.      *
  258.      * @param [type] $fullname
  259.      * @return string
  260.      */
  261.     public function getContactByEmail(string $email): ?string
  262.     {
  263.         /** This represents paramater needed for Xero getContacts */
  264.         $modifiedSince = new \DateTime('2010-01-01');
  265.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  266.         $order = "Name ASC";
  267.         $page = 1;
  268.         $searchTerm = $email;
  269.         $includeArchived = true;
  270.         $summaryOnly = true;
  272.         $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  274.         foreach ($contacts as $contact) {
  275.             if ($contact['email_address'] == $email) {
  276.                 return $contact['contact_id'];
  277.             }
  278.         }
  280.         return null;
  281.     }
  283.     /**
  284.      * Get contacts by id
  285.      *
  286.      * @param [type] $fullname
  287.      * @return obj
  288.      */
  289.     public function getContactById(string $contactId)
  290.     {
  291.         try {
  292.             $contacts = $this->xeroAccountingManager->getContact($this->xeroTenantId, $contactId);
  293.         }
  294.         catch (Exception $e) {
  295.             $this->throwExceptionMessage($e->getMessage());
  296.         }
  297.         
  298.         if ($contacts) {
  299.             return $contacts[0];
  300.         }
  302.         return null;
  303.     }
  305.     /**
  306.      * Get contacts by name
  307.      *
  308.      * @param [type] $fullname
  309.      * @return string
  310.      */
  311.     public function getContactByOrderDetails(OrderDetails $orderDetails): ?string
  312.     {
  313.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  315.         $user = $this->userRepository->findOneBy(['email' => $orderBillingDetails->getEmailAddress()]);
  316.         $fullName = $orderBillingDetails->getFirstName() .' '. $orderBillingDetails->getLastName();
  317.         // TODO: ENABLED when client agree to use the same ID for the same contact integrated with the system
  318.         // if ($user) {
  319.             // $fullName = $user->getFirstName() .' '. $user->getLastName() . ' - ' . $user->getId();
  320.         //     $userInformation = $user->getUserInformation();
  321.         //     return $userInformation->getXeroId();
  322.         // }             
  324.         /** This represents paramater needed for Xero getContacts */
  325.         $modifiedSince = new \DateTime('2020-01-01');
  326.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  327.         $order = "Name ASC";
  328.         $page = 1;
  329.         // $searchTerm = $fullName;
  330.         $searchTerm =  $orderBillingDetails->getEmailAddress();
  331.         $includeArchived = true;
  332.         $summaryOnly = true;
  334.         try {
  335.             $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  336.         } catch(ApiException $e) {
  337.             $this->throwXeroException($e);
  338.         } 
  340.         foreach ($contacts as $contact) {
  341.             // if (strtolower($contact['name']) == strtolower($fullName)) {
  342.             if (str_contains(strtolower($contact['name']),strtolower($fullName) )) {
  343.                 return $contact['contact_id'];
  344.             }
  345.         }
  347.         return null;
  348.     }
  349.     
  350.     /**
  351.      * Create Xero contact 
  352.      *
  353.      * @param User $user
  354.      * @return string
  355.      */
  356.     public function createContactByOrderDetails(OrderDetails $orderDetails): string 
  357.     {
  358.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  360.         $contact = new Contact;
  361.         $contact->setName($orderBillingDetails->getFirstName() . ' ' . $orderBillingDetails->getLastName() . ' - '. $orderDetails->getId())
  362.                 ->setFirstName($orderBillingDetails->getFirstName())
  363.                 ->setLastName($orderBillingDetails->getLastName())
  364.                 ->setEmailAddress($orderBillingDetails->getEmailAddress());
  366.         $address = new Address();
  367.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  368.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  369.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  370.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  371.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  372.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  374.         $arr_addresses = [];
  375.         array_push($arr_addresses, $address);
  376.         $contact->setAddresses($arr_addresses);
  378.         $arr_contacts = [];
  379.         array_push($arr_contacts, $contact);
  381.         $contacts = new Contacts;
  382.         $contacts->setContacts($arr_contacts);
  384.         try {
  385.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  386.         } catch(ApiException $e) {
  387.             $this->throwXeroException($e);
  388.         } 
  390.         if ($apiResponse[0]['has_validation_errors']) {
  391.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  392.         }
  394.         return $apiResponse[0]['contact_id'];
  395.     }
  397.     /**
  398.      * Create Xero contact 
  399.      *
  400.      * @param User $user
  401.      * @return string
  402.      */
  403.     public function createGuestContactByOrderDetails(OrderDetails $orderDetails): string 
  404.     {
  405.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  407.         $contact = new Contact;
  408.         $contact->setName($orderBillingDetails->getFirstName() . ' ' . $orderBillingDetails->getLastName())
  409.                 ->setFirstName($orderBillingDetails->getFirstName())
  410.                 ->setLastName($orderBillingDetails->getLastName())
  411.                 ->setEmailAddress($orderBillingDetails->getEmailAddress());
  413.         $arr_contacts = [];
  414.         array_push($arr_contacts, $contact);
  416.         $contacts = new Contacts;
  417.         $contacts->setContacts($arr_contacts);
  419.         try {
  420.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  421.         } catch(ApiException $e) {
  422.             $this->throwXeroException($e);
  423.         } 
  425.         if ($apiResponse[0]['has_validation_errors']) {
  426.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  427.         }
  429.         return $apiResponse[0]['contact_id'];
  430.     }
  431.     
  432.     /**
  433.      * Update Xero contact details
  434.      *
  435.      * @param OrderDetails $orderDetails
  436.      * @param [type] $xeroContactId
  437.      * @return void
  438.      */
  439.     public function updateContactByOrderDetails(OrderDetails $orderDetails, $xeroContactId)
  440.     {
  441.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  443.         $contact = new Contact();
  444.         $contact
  445.             // ->setName($orderBillingDetails->getFirstName() . ' ' . $orderBillingDetails->getLastName())
  446.             ->setFirstName($orderBillingDetails->getFirstName())
  447.             ->setLastName($orderBillingDetails->getLastName())
  448.             ->setEmailAddress($orderBillingDetails->getEmailAddress())
  449.             ->setContactID($xeroContactId)
  450.             // TODO: set other fields such as address
  451.         ;
  453.         $address = new Address();
  454.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  455.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  456.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  457.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  458.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  459.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  461.         $arr_addresses = [];
  462.         array_push($arr_addresses, $address);
  463.         $contact->setAddresses($arr_addresses);
  465.         $arr_contacts = [];
  466.         array_push($arr_contacts, $contact);
  468.         $contacts = new Contacts;
  469.         $contacts->setContacts($arr_contacts);
  471.         $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  473.         if ($apiResponse[0]['has_validation_errors']) {
  474.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  475.         }
  476.         
  477.         return $apiResponse[0]['contact_id'];
  478.     }
  480.     
  481.     /**
  482.      * Check if contact exists on current XERO contact Id
  483.      *
  484.      * @param [type] $contactId
  485.      * @return void
  486.      */
  487.     public function checkContactExists($xeroContactId) {
  488.         $isExist = false;
  490.         try {
  491.             $apiResponse = $this->xeroAccountingManager->getContact($this->xeroTenantId, $xeroContactId);
  492.         } catch (ApiException $e) {
  493.             return $isExist;
  494.         }
  496.         if (!$apiResponse[0]['HasValidationErrors']) {
  497.             $isExist = true;
  498.         }
  499.     
  500.         return $isExist;
  501.     }
  503.     
  504.     /**
  505.      * Update contact
  506.      *
  507.      * @param OrderDetails $orderDetails
  508.      * @param string $xeroContactId
  509.      * @return void
  510.      */
  511.     public function updateContactById(OrderDetails $orderDetails, string $xeroContactId)
  512.     {
  513.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  515.         $contact = new Contact();
  516.         $contact
  517.             ->setFirstName($orderBillingDetails->getFirstName())
  518.             ->setLastName($orderBillingDetails->getLastName())
  519.         ;
  521.         $address = new Address();
  522.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  523.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  524.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  525.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  526.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  527.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  529.         $arr_addresses = [];
  530.         array_push($arr_addresses, $address);
  531.         $contact->setAddresses($arr_addresses);
  533.         $arr_contacts = [];
  534.         array_push($arr_contacts, $contact);
  536.         $contacts = new Contacts;
  537.         $contacts->setContacts($arr_contacts);
  539.         try {
  540.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  541.         } catch(ApiException $e) {
  542.             $this->throwXeroException($e);
  543.         } 
  545.         if ($apiResponse[0]['has_validation_errors']) {
  546.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  547.         }
  548.         
  549.         return $apiResponse[0]['contact_id'];
  550.     }
  552.     /**
  553.      * Get contacts by organisation name
  554.      *
  555.      * @param OrderDetails $orderDetails
  556.      * @return string
  557.      */
  558.     public function getContactOrganisationByOrderDetails(OrderDetails $orderDetails): ?string
  559.     {
  560.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  561.         $fullName = $orderBillingDetails->getOrganisation();
  563.         /** This represents paramater needed for Xero getContacts */
  564.         $modifiedSince = new \DateTime('2020-01-01');
  565.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  566.         $order = "Name ASC";
  567.         $page = 1;
  568.         $searchTerm = $fullName;
  569.         // $searchTerm =  $orderBillingDetails->getEmailAddress();
  570.         $includeArchived = true;
  571.         $summaryOnly = true;
  573.         // Set maximum length of a full name to 50
  574.         if (strlen($searchTerm) > 50) {
  575.             // Truncate the string to 50 characters
  576.             $searchTerm = substr($searchTerm, 0, 50);
  578.         }
  580.         try {
  581.             $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  582.         } catch(ApiException $e) {
  583.             $this->throwXeroException($e);
  584.         } 
  586.         foreach ($contacts as $contact) { // Make sure that the actual name is exactly the same as the search results
  587.             if (strtolower($contact['name']) == strtolower($fullName)) {
  588.                 return $contact['contact_id'];
  589.             }
  590.         }
  592.         return null;
  593.     }
  595.     /**
  596.      * Create Xero contact with organisation name 
  597.      *
  598.      * @param User $user
  599.      * @return string
  600.      */
  601.     public function createContactOrganisationByOrderDetails(OrderDetails $orderDetails): string 
  602.     {
  603.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  605.         $contact = new Contact;
  606.         $contact->setName($orderBillingDetails->getOrganisation())
  607.                 ->setFirstName($orderBillingDetails->getFirstName())
  608.                 ->setLastName($orderBillingDetails->getLastName())
  609.                 ->setEmailAddress($orderBillingDetails->getEmailAddress());
  611.         $address = new Address();
  612.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  613.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  614.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  615.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  616.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  617.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  619.         $arr_contacts = [];
  620.         array_push($arr_contacts, $contact);
  622.         $contacts = new Contacts;
  623.         $contacts->setContacts($arr_contacts);
  625.         try {
  626.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  627.         } catch(ApiException $e) {
  628.             $this->throwXeroException($e);
  629.         } 
  631.         if ($apiResponse[0]['has_validation_errors']) {
  632.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  633.         }
  635.         return $apiResponse[0]['contact_id'];
  636.     }
  638.     /**
  639.      * Gets all the additional persons from the contact based on XERO ID
  640.      *
  641.      * @param string $xeroID
  642.      * @return void|arr
  643.      */
  644.     private function getOrganisationAdditionalPersonByXeroId(string $xeroID)
  645.     {
  646.         $result = [];
  647.         $contact = $this->getContactById($xeroID);
  649.         if (!empty($contact['contact_persons'])) {
  650.             return $contact['contact_persons'];
  651.         }
  653.         return $result;
  654.     }
  656.     private function updateContactWithAdditionalPersonDetails(User $user, $xeroContactId) 
  657.     {
  658.         // Check if the order billing details already exists as one of the additional person arr
  659.         $additionalPersonsArr = $this->getOrganisationAdditionalPersonByXeroId($xeroContactId);
  660.         $isExist = false;
  661.         foreach ($additionalPersonsArr as $personArr) {
  662.             if ($user->getFirstName() == $personArr->getFirstName() && $user->getLastName() == $personArr->getLastName() && $user->getEmailAddress() == $personArr->getEmailAddress()) {
  663.                 $isExist = true;
  664.                 break;
  665.             }
  666.         }
  668.         if ($isExist) { // If alreadt exist, dont update anything
  669.             return null;
  670.         }
  672.         $person = new ContactPerson;
  673.         $person
  674.             ->setFirstName($user->getFirstName())
  675.             ->setLastName($user->getLastName())
  676.             ->setEmailAddress($user->getEmailAddress())
  677.             ->setIncludeInEmails(false)
  678.         ;
  680.         array_push($additionalPersonsArr, $person);
  681.         $contact = new Contact;
  682.         $contact
  683.             ->setContactPersons($additionalPersonsArr)
  684.         ;
  686.         $arr_contacts = [];
  687.         array_push($arr_contacts, $contact);
  689.         $contacts = new Contacts;
  690.         $contacts->setContacts($arr_contacts);
  692.         // Update the contact with additional person data
  693.         try {
  694.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  695.         } catch(ApiException $e) {
  696.             $this->throwXeroException($e);
  697.         } 
  699.         if ($apiResponse[0]['has_validation_errors']) {
  700.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  701.         }
  702.         
  703.         return $apiResponse[0]['contact_id'];
  704.     }
  706.     /**
  707.      * Adds a new person as an additional person in the contact
  708.      *
  709.      * @param OrderDetails $orderDetails
  710.      * @param [type] $xeroContactId
  711.      * @return void
  712.      */
  713.     public function updateOrganisationWithAdditionalPersonByOrderDetails(OrderDetails $orderDetails, $xeroContactId)
  714.     {
  715.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  717.         // Check if the order billing details already exists as one of the additional person arr
  718.         $additionalPersonsArr = $this->getOrganisationAdditionalPersonByXeroId($xeroContactId);
  719.         $isExist = false;
  720.         foreach ($additionalPersonsArr as $personArr) {
  721.             if ($orderBillingDetails->getFirstName() == $personArr->getFirstName() && $orderBillingDetails->getLastName() == $personArr->getLastName() && $orderBillingDetails->getEmailAddress() == $personArr->getEmailAddress()) {
  722.                 $isExist = true;
  723.                 break;
  724.             }
  725.         }
  727.         if ($isExist) { // If alreadt exist, dont update anything
  728.             return null;
  729.         }
  731.         $person = new ContactPerson;
  732.         $person
  733.             ->setFirstName($orderBillingDetails->getFirstName())
  734.             ->setLastName($orderBillingDetails->getLastName())
  735.             ->setEmailAddress($orderBillingDetails->getEmailAddress())
  736.             ->setIncludeInEmails(false)
  737.         ;
  739.         array_push($additionalPersonsArr, $person);
  740.         $contact = new Contact;
  741.         $contact
  742.             ->setContactPersons($additionalPersonsArr)
  743.         ;
  745.         $arr_contacts = [];
  746.         array_push($arr_contacts, $contact);
  748.         $contacts = new Contacts;
  749.         $contacts->setContacts($arr_contacts);
  751.         // Update the organisation contact
  752.         try {
  753.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  754.         } catch(ApiException $e) {
  755.            $this->throwXeroException($e);
  756.         }
  757.             
  758.         if ($apiResponse[0]['has_validation_errors']) {
  759.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  760.         }
  761.         
  762.         return $apiResponse[0]['contact_id'];
  763.     }
  765.     /**
  766.      * DELETE CONTACT
  767.      *
  768.      * @param User $user
  769.      * @return void
  770.      */
  771.     public function deleteContact(User $user)
  772.     {
  773.         $userInformation = $user->getUserInformation();
  774.         $xeroContactId = $userInformation->getXeroId();
  776.         $contact = new Contact();
  777.         $contact
  778.             ->setContactID($xeroContactId)
  779.             ->setContactStatus('ARCHIVED')
  780.         ;
  782.         $arr_contacts = [];
  783.         array_push($arr_contacts, $contact);
  785.         $contacts = new Contacts;
  786.         $contacts->setContacts($arr_contacts);
  788.         try {
  789.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  790.         } catch(ApiException $e) {
  791.             $this->throwXeroException($e);
  792.         } catch(Exception $e) {
  793.             return;
  794.         } 
  796.         if ($apiResponse[0]['has_validation_errors']) {
  797.             // return;
  798.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  799.         }
  800.         
  801.         return $apiResponse[0]['contact_id'];
  802.     }
  804.     private function throwXeroException(ApiException $e) {
  805.         $error = AccountingObjectSerializer::deserialize(
  806.             $e->getResponseBody(),
  807.             '\XeroAPI\XeroPHP\Models\Accounting\Error',
  808.             []
  809.         );
  810.         $message = "ApiException - " . $error->getElements()[0]["validation_errors"][0]["message"];
  811.         $this->throwExceptionMessage($message);
  812.     }
  813. }