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.             $this->throwXeroException($e);
  102.         } 
  104.         if(count($contacts) > 0) {
  105.             return $contacts[0]['contact_id'];
  106.         }
  108.         return null;
  109.     }
  111.     /**
  112.      * Create Xero contact 
  113.      *
  114.      * @param User $user
  115.      * @return string
  116.      */
  117.     public function createContactByProjectName(FilmProject $filmProject): string 
  118.     {
  119.         $contact = new Contact;
  121.         $user = $filmProject->getOwner();
  123.         $contact->setName($filmProject->getTitle()) // Unique name here
  124.             ->setFirstName($user->getFirstName())
  125.             ->setLastName($user->getLastName())
  126.             ->setEmailAddress($user->getEmail())
  127.         ;
  129.         if ($user->getUserAddress()) {
  130.             $userAddress = $user->getUserAddress();
  131.             
  132.             $address = new Address();
  133.             $address->setAddressType(Address::ADDRESS_TYPE_STREET);
  134.             if ($userAddress->getStreet()) $address->setAddressLine1($userAddress->getStreet());
  135.             if ($userAddress->getCity()) $address->setCity($userAddress->getCity());
  136.             if ($userAddress->getState()) $address->setRegion($userAddress->getState());
  137.             if ($userAddress->getPostcode()) $address->setPostalCode($userAddress->getPostcode());
  138.             if ($userAddress->getCountry()) $address->setCountry($userAddress->getCountry());
  140.             $arr_addresses = [];
  141.             array_push($arr_addresses, $address);
  142.             $contact->setAddresses($arr_addresses);
  143.         }
  145.         $arr_contacts = [];
  146.         array_push($arr_contacts, $contact);
  148.         $contacts = new Contacts;
  149.         $contacts->setContacts($arr_contacts);
  151.         try {
  152.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  153.         } catch(ApiException $e) {
  154.             $this->throwXeroException($e);
  155.         } 
  157.         if ($apiResponse[0]['has_validation_errors']) {
  158.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  159.         }
  161.         return $apiResponse[0]['contact_id'];
  162.     }
  164.     /**
  165.      * Update contact
  166.      *
  167.      * @param User $user
  168.      * @return void
  169.      */
  170.     public function updateContact(User $user)
  171.     {
  172.         $userInformation = $user->getUserInformation();
  173.         $userAddress = $user->getUserAddress();
  174.         $xeroContactId = $userInformation->getXeroId();
  176.         $arr_addresses = [];
  177.         $address = (new Address())
  178.             ->setAddressType(Address::ADDRESS_TYPE_STREET)
  179.             ->setAddressLine1($userAddress->getStreet())
  180.             ->setCity($userAddress->getCity())
  181.             ->setPostalCode($userAddress->getPostcode())
  182.         ;
  183.         array_push($arr_addresses, $address);
  185.         $contact = new Contact();
  186.         $contact
  187.             ->setName($user->getFirstName() . ' ' . $user->getLastName())
  188.             ->setFirstName($user->getFirstName())
  189.             ->setLastName($user->getLastName())
  190.             ->setContactID($xeroContactId)
  191.             ->setAddresses($arr_addresses)
  192.         ;
  194.         $arr_contacts = [];
  195.         array_push($arr_contacts, $contact);
  197.         $contacts = new Contacts;
  198.         $contacts->setContacts($arr_contacts);
  200.         try {
  201.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  202.         } catch(ApiException $e) {
  203.             $this->throwXeroException($e);
  204.         } 
  206.         if ($apiResponse[0]['has_validation_errors']) {
  207.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  208.         }
  209.         
  210.         return $apiResponse[0]['contact_id'];
  211.     }
  213.     /**
  214.      * Get contacts by email
  215.      *
  216.      * @param [type] $fullname
  217.      * @return string
  218.      */
  219.     public function getContactByUser(User $user): ?string
  220.     {
  221.         $fullName = $user->getFirstName() . ' ' . $user->getLastName();
  223.         /** This represents paramater needed for Xero getContacts */
  224.         $modifiedSince = new \DateTime('2010-01-01');
  225.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  226.         $order = "Name ASC";
  227.         $page = 1;
  228.         $searchTerm = $fullName; // since xero has contactName as its unique name
  229.         $includeArchived = true;
  230.         $summaryOnly = true;
  232.         $isExistContact = false;
  233.         try {
  234.             $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  235.         } catch(ApiException $e) {
  236.             $this->throwXeroException($e);
  237.         } 
  239.         if(count($contacts) > 0) $isExistContact = true;
  240.         foreach ($contacts as $contact) {
  241.             if (strtolower($contact['email_address']) == strtolower($user->getEmailAddress())) {
  242.                 return $contact['contact_id'];
  243.             }
  244.         }
  246.         if ($isExistContact) { // If contact found but no email address found in that contact, add it as an additional person
  247.             $xeroContactId = $contacts[0]['contact_id']; // Get the first contact details ID
  248.             return $this->updateContactWithAdditionalPersonDetails($user, $xeroContactId);
  249.         }
  251.         return null;
  252.     }
  254.     /**
  255.      * Get contacts by email
  256.      *
  257.      * @param [type] $fullname
  258.      * @return string
  259.      */
  260.     public function getContactByEmail(string $email): ?string
  261.     {
  262.         /** This represents paramater needed for Xero getContacts */
  263.         $modifiedSince = new \DateTime('2010-01-01');
  264.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  265.         $order = "Name ASC";
  266.         $page = 1;
  267.         $searchTerm = $email;
  268.         $includeArchived = true;
  269.         $summaryOnly = true;
  271.         $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  273.         foreach ($contacts as $contact) {
  274.             if ($contact['email_address'] == $email) {
  275.                 return $contact['contact_id'];
  276.             }
  277.         }
  279.         return null;
  280.     }
  282.     /**
  283.      * Get contacts by id
  284.      *
  285.      * @param [type] $fullname
  286.      * @return obj
  287.      */
  288.     public function getContactById(string $contactId)
  289.     {
  290.         try {
  291.             $contacts = $this->xeroAccountingManager->getContact($this->xeroTenantId, $contactId);
  292.         }
  293.         catch (Exception $e) {
  294.             $this->throwExceptionMessage($e->getMessage());
  295.         }
  296.         
  297.         if ($contacts) {
  298.             return $contacts[0];
  299.         }
  301.         return null;
  302.     }
  304.     /**
  305.      * Get contacts by name
  306.      *
  307.      * @param [type] $fullname
  308.      * @return string
  309.      */
  310.     public function getContactByOrderDetails(OrderDetails $orderDetails): ?string
  311.     {
  312.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  314.         $user = $this->userRepository->findOneBy(['email' => $orderBillingDetails->getEmailAddress()]);
  315.         $fullName = $orderBillingDetails->getFirstName() .' '. $orderBillingDetails->getLastName();
  316.         // TODO: ENABLED when client agree to use the same ID for the same contact integrated with the system
  317.         // if ($user) {
  318.             // $fullName = $user->getFirstName() .' '. $user->getLastName() . ' - ' . $user->getId();
  319.         //     $userInformation = $user->getUserInformation();
  320.         //     return $userInformation->getXeroId();
  321.         // }             
  323.         /** This represents paramater needed for Xero getContacts */
  324.         $modifiedSince = new \DateTime('2020-01-01');
  325.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  326.         $order = "Name ASC";
  327.         $page = 1;
  328.         // $searchTerm = $fullName;
  329.         $searchTerm =  $orderBillingDetails->getEmailAddress();
  330.         $includeArchived = true;
  331.         $summaryOnly = true;
  333.         try {
  334.             $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  335.         } catch(ApiException $e) {
  336.             $this->throwXeroException($e);
  337.         } 
  339.         foreach ($contacts as $contact) {
  340.             // if (strtolower($contact['name']) == strtolower($fullName)) {
  341.             if (str_contains(strtolower($contact['name']),strtolower($fullName) )) {
  342.                 return $contact['contact_id'];
  343.             }
  344.         }
  346.         return null;
  347.     }
  348.     
  349.     /**
  350.      * Create Xero contact 
  351.      *
  352.      * @param User $user
  353.      * @return string
  354.      */
  355.     public function createContactByOrderDetails(OrderDetails $orderDetails): string 
  356.     {
  357.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  359.         $contact = new Contact;
  360.         $contact->setName($orderBillingDetails->getFirstName() . ' ' . $orderBillingDetails->getLastName() . ' - '. $orderDetails->getId())
  361.                 ->setFirstName($orderBillingDetails->getFirstName())
  362.                 ->setLastName($orderBillingDetails->getLastName())
  363.                 ->setEmailAddress($orderBillingDetails->getEmailAddress());
  365.         $address = new Address();
  366.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  367.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  368.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  369.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  370.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  371.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  373.         $arr_addresses = [];
  374.         array_push($arr_addresses, $address);
  375.         $contact->setAddresses($arr_addresses);
  377.         $arr_contacts = [];
  378.         array_push($arr_contacts, $contact);
  380.         $contacts = new Contacts;
  381.         $contacts->setContacts($arr_contacts);
  383.         try {
  384.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  385.         } catch(ApiException $e) {
  386.             $this->throwXeroException($e);
  387.         } 
  389.         if ($apiResponse[0]['has_validation_errors']) {
  390.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  391.         }
  393.         return $apiResponse[0]['contact_id'];
  394.     }
  396.     /**
  397.      * Create Xero contact 
  398.      *
  399.      * @param User $user
  400.      * @return string
  401.      */
  402.     public function createGuestContactByOrderDetails(OrderDetails $orderDetails): string 
  403.     {
  404.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  406.         $contact = new Contact;
  407.         $contact->setName($orderBillingDetails->getFirstName() . ' ' . $orderBillingDetails->getLastName())
  408.                 ->setFirstName($orderBillingDetails->getFirstName())
  409.                 ->setLastName($orderBillingDetails->getLastName())
  410.                 ->setEmailAddress($orderBillingDetails->getEmailAddress());
  412.         $arr_contacts = [];
  413.         array_push($arr_contacts, $contact);
  415.         $contacts = new Contacts;
  416.         $contacts->setContacts($arr_contacts);
  418.         try {
  419.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  420.         } catch(ApiException $e) {
  421.             $this->throwXeroException($e);
  422.         } 
  424.         if ($apiResponse[0]['has_validation_errors']) {
  425.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  426.         }
  428.         return $apiResponse[0]['contact_id'];
  429.     }
  430.     
  431.     /**
  432.      * Update Xero contact details
  433.      *
  434.      * @param OrderDetails $orderDetails
  435.      * @param [type] $xeroContactId
  436.      * @return void
  437.      */
  438.     public function updateContactByOrderDetails(OrderDetails $orderDetails, $xeroContactId)
  439.     {
  440.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  442.         $contact = new Contact();
  443.         $contact
  444.             // ->setName($orderBillingDetails->getFirstName() . ' ' . $orderBillingDetails->getLastName())
  445.             ->setFirstName($orderBillingDetails->getFirstName())
  446.             ->setLastName($orderBillingDetails->getLastName())
  447.             ->setEmailAddress($orderBillingDetails->getEmailAddress())
  448.             ->setContactID($xeroContactId)
  449.             // TODO: set other fields such as address
  450.         ;
  452.         $address = new Address();
  453.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  454.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  455.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  456.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  457.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  458.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  460.         $arr_addresses = [];
  461.         array_push($arr_addresses, $address);
  462.         $contact->setAddresses($arr_addresses);
  464.         $arr_contacts = [];
  465.         array_push($arr_contacts, $contact);
  467.         $contacts = new Contacts;
  468.         $contacts->setContacts($arr_contacts);
  470.         $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  472.         if ($apiResponse[0]['has_validation_errors']) {
  473.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  474.         }
  475.         
  476.         return $apiResponse[0]['contact_id'];
  477.     }
  479.     
  480.     /**
  481.      * Check if contact exists on current XERO contact Id
  482.      *
  483.      * @param [type] $contactId
  484.      * @return void
  485.      */
  486.     public function checkContactExists($xeroContactId) {
  487.         $isExist = false;
  489.         try {
  490.             $apiResponse = $this->xeroAccountingManager->getContact($this->xeroTenantId, $xeroContactId);
  491.         } catch (ApiException $e) {
  492.             return $isExist;
  493.         }
  495.         if (!$apiResponse[0]['HasValidationErrors']) {
  496.             $isExist = true;
  497.         }
  498.     
  499.         return $isExist;
  500.     }
  502.     
  503.     /**
  504.      * Update contact
  505.      *
  506.      * @param OrderDetails $orderDetails
  507.      * @param string $xeroContactId
  508.      * @return void
  509.      */
  510.     public function updateContactById(OrderDetails $orderDetails, string $xeroContactId)
  511.     {
  512.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  514.         $contact = new Contact();
  515.         $contact
  516.             ->setFirstName($orderBillingDetails->getFirstName())
  517.             ->setLastName($orderBillingDetails->getLastName())
  518.         ;
  520.         $address = new Address();
  521.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  522.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  523.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  524.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  525.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  526.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  528.         $arr_addresses = [];
  529.         array_push($arr_addresses, $address);
  530.         $contact->setAddresses($arr_addresses);
  532.         $arr_contacts = [];
  533.         array_push($arr_contacts, $contact);
  535.         $contacts = new Contacts;
  536.         $contacts->setContacts($arr_contacts);
  538.         try {
  539.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  540.         } catch(ApiException $e) {
  541.             $this->throwXeroException($e);
  542.         } 
  544.         if ($apiResponse[0]['has_validation_errors']) {
  545.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  546.         }
  547.         
  548.         return $apiResponse[0]['contact_id'];
  549.     }
  551.     /**
  552.      * Get contacts by organisation name
  553.      *
  554.      * @param OrderDetails $orderDetails
  555.      * @return string
  556.      */
  557.     public function getContactOrganisationByOrderDetails(OrderDetails $orderDetails): ?string
  558.     {
  559.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  560.         $fullName = $orderBillingDetails->getOrganisation();
  562.         /** This represents paramater needed for Xero getContacts */
  563.         $modifiedSince = new \DateTime('2020-01-01');
  564.         $where = 'ContactStatus=="' . Contact::CONTACT_STATUS_ACTIVE . '"';
  565.         $order = "Name ASC";
  566.         $page = 1;
  567.         $searchTerm = $fullName;
  568.         // $searchTerm =  $orderBillingDetails->getEmailAddress();
  569.         $includeArchived = true;
  570.         $summaryOnly = true;
  572.         // Set maximum length of a full name to 50
  573.         if (strlen($searchTerm) > 50) {
  574.             // Truncate the string to 50 characters
  575.             $searchTerm = substr($searchTerm, 0, 50);
  577.         }
  579.         try {
  580.             $contacts = $this->xeroAccountingManager->getContacts($this->xeroTenantId, $modifiedSince, $where, $order, null, $page, $includeArchived, $summaryOnly, $searchTerm);
  581.         } catch(ApiException $e) {
  582.             $this->throwXeroException($e);
  583.         } 
  585.         foreach ($contacts as $contact) { // Make sure that the actual name is exactly the same as the search results
  586.             if (strtolower($contact['name']) == strtolower($fullName)) {
  587.                 return $contact['contact_id'];
  588.             }
  589.         }
  591.         return null;
  592.     }
  594.     /**
  595.      * Create Xero contact with organisation name 
  596.      *
  597.      * @param User $user
  598.      * @return string
  599.      */
  600.     public function createContactOrganisationByOrderDetails(OrderDetails $orderDetails): string 
  601.     {
  602.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  604.         $contact = new Contact;
  605.         $contact->setName($orderBillingDetails->getOrganisation())
  606.                 ->setFirstName($orderBillingDetails->getFirstName())
  607.                 ->setLastName($orderBillingDetails->getLastName())
  608.                 ->setEmailAddress($orderBillingDetails->getEmailAddress());
  610.         $address = new Address();
  611.         $address->setAddressType(Address::ADDRESS_TYPE_POBOX);
  612.         if ($orderBillingDetails->getStreet()) $address->setAddressLine1($orderBillingDetails->getStreet());
  613.         if ($orderBillingDetails->getSuburb()) $address->setCity($orderBillingDetails->getSuburb());
  614.         if ($orderBillingDetails->getState()) $address->setRegion($orderBillingDetails->getState());
  615.         if ($orderBillingDetails->getPostcode()) $address->setPostalCode($orderBillingDetails->getPostcode());
  616.         if ($orderBillingDetails->getCountry()) $address->setCountry($orderBillingDetails->getCountry());
  618.         $arr_contacts = [];
  619.         array_push($arr_contacts, $contact);
  621.         $contacts = new Contacts;
  622.         $contacts->setContacts($arr_contacts);
  624.         try {
  625.             $apiResponse = $this->xeroAccountingManager->createContacts($this->xeroTenantId, $contacts);
  626.         } catch(ApiException $e) {
  627.             $this->throwXeroException($e);
  628.         } 
  630.         if ($apiResponse[0]['has_validation_errors']) {
  631.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  632.         }
  634.         return $apiResponse[0]['contact_id'];
  635.     }
  637.     /**
  638.      * Gets all the additional persons from the contact based on XERO ID
  639.      *
  640.      * @param string $xeroID
  641.      * @return void|arr
  642.      */
  643.     private function getOrganisationAdditionalPersonByXeroId(string $xeroID)
  644.     {
  645.         $result = [];
  646.         $contact = $this->getContactById($xeroID);
  648.         if (!empty($contact['contact_persons'])) {
  649.             return $contact['contact_persons'];
  650.         }
  652.         return $result;
  653.     }
  655.     private function updateContactWithAdditionalPersonDetails(User $user, $xeroContactId) 
  656.     {
  657.         // Check if the order billing details already exists as one of the additional person arr
  658.         $additionalPersonsArr = $this->getOrganisationAdditionalPersonByXeroId($xeroContactId);
  659.         $isExist = false;
  660.         foreach ($additionalPersonsArr as $personArr) {
  661.             if ($user->getFirstName() == $personArr->getFirstName() && $user->getLastName() == $personArr->getLastName() && $user->getEmailAddress() == $personArr->getEmailAddress()) {
  662.                 $isExist = true;
  663.                 break;
  664.             }
  665.         }
  667.         if ($isExist) { // If alreadt exist, dont update anything
  668.             return null;
  669.         }
  671.         $person = new ContactPerson;
  672.         $person
  673.             ->setFirstName($user->getFirstName())
  674.             ->setLastName($user->getLastName())
  675.             ->setEmailAddress($user->getEmailAddress())
  676.             ->setIncludeInEmails(false)
  677.         ;
  679.         array_push($additionalPersonsArr, $person);
  680.         $contact = new Contact;
  681.         $contact
  682.             ->setContactPersons($additionalPersonsArr)
  683.         ;
  685.         $arr_contacts = [];
  686.         array_push($arr_contacts, $contact);
  688.         $contacts = new Contacts;
  689.         $contacts->setContacts($arr_contacts);
  691.         // Update the contact with additional person data
  692.         try {
  693.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  694.         } catch(ApiException $e) {
  695.             $this->throwXeroException($e);
  696.         } 
  698.         if ($apiResponse[0]['has_validation_errors']) {
  699.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  700.         }
  701.         
  702.         return $apiResponse[0]['contact_id'];
  703.     }
  705.     /**
  706.      * Adds a new person as an additional person in the contact
  707.      *
  708.      * @param OrderDetails $orderDetails
  709.      * @param [type] $xeroContactId
  710.      * @return void
  711.      */
  712.     public function updateOrganisationWithAdditionalPersonByOrderDetails(OrderDetails $orderDetails, $xeroContactId)
  713.     {
  714.         $orderBillingDetails = $orderDetails->getOrderBillingDetails();
  716.         // Check if the order billing details already exists as one of the additional person arr
  717.         $additionalPersonsArr = $this->getOrganisationAdditionalPersonByXeroId($xeroContactId);
  718.         $isExist = false;
  719.         foreach ($additionalPersonsArr as $personArr) {
  720.             if ($orderBillingDetails->getFirstName() == $personArr->getFirstName() && $orderBillingDetails->getLastName() == $personArr->getLastName() && $orderBillingDetails->getEmailAddress() == $personArr->getEmailAddress()) {
  721.                 $isExist = true;
  722.                 break;
  723.             }
  724.         }
  726.         if ($isExist) { // If alreadt exist, dont update anything
  727.             return null;
  728.         }
  730.         $person = new ContactPerson;
  731.         $person
  732.             ->setFirstName($orderBillingDetails->getFirstName())
  733.             ->setLastName($orderBillingDetails->getLastName())
  734.             ->setEmailAddress($orderBillingDetails->getEmailAddress())
  735.             ->setIncludeInEmails(false)
  736.         ;
  738.         array_push($additionalPersonsArr, $person);
  739.         $contact = new Contact;
  740.         $contact
  741.             ->setContactPersons($additionalPersonsArr)
  742.         ;
  744.         $arr_contacts = [];
  745.         array_push($arr_contacts, $contact);
  747.         $contacts = new Contacts;
  748.         $contacts->setContacts($arr_contacts);
  750.         // Update the organisation contact
  751.         try {
  752.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  753.         } catch(ApiException $e) {
  754.            $this->throwXeroException($e);
  755.         }
  756.             
  757.         if ($apiResponse[0]['has_validation_errors']) {
  758.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  759.         }
  760.         
  761.         return $apiResponse[0]['contact_id'];
  762.     }
  764.     /**
  765.      * DELETE CONTACT
  766.      *
  767.      * @param User $user
  768.      * @return void
  769.      */
  770.     public function deleteContact(User $user)
  771.     {
  772.         $userInformation = $user->getUserInformation();
  773.         $xeroContactId = $userInformation->getXeroId();
  775.         $contact = new Contact();
  776.         $contact
  777.             ->setContactID($xeroContactId)
  778.             ->setContactStatus('ARCHIVED')
  779.         ;
  781.         $arr_contacts = [];
  782.         array_push($arr_contacts, $contact);
  784.         $contacts = new Contacts;
  785.         $contacts->setContacts($arr_contacts);
  787.         try {
  788.             $apiResponse = $this->xeroAccountingManager->updateContact($this->xeroTenantId, $xeroContactId, $contacts);
  789.         } catch(ApiException $e) {
  790.             $this->throwXeroException($e);
  791.         } catch(Exception $e) {
  792.             return;
  793.         } 
  795.         if ($apiResponse[0]['has_validation_errors']) {
  796.             // return;
  797.             $this->throwExceptionMessage($apiResponse[0]['validation_errors'][0]['message']);
  798.         }
  799.         
  800.         return $apiResponse[0]['contact_id'];
  801.     }
  803.     private function throwXeroException(ApiException $e) {
  804.         $error = AccountingObjectSerializer::deserialize(
  805.             $e->getResponseBody(),
  806.             '\XeroAPI\XeroPHP\Models\Accounting\Error',
  807.             []
  808.         );
  809.         $message = "ApiException - " . $error->getElements()[0]["validation_errors"][0]["message"];
  810.         $this->throwExceptionMessage($message);
  811.     }
  812. }