acaresydney_ts/Xero.php

<?php
namespace Biukop;

use \XeroPHP\Application\PrivateApplication;
use \XeroPHP\Remote\Exception\RateLimitExceededException; 

class Xero {
    private $xero;
    private $clientgroup="48646f3d-cf5e-4fea-8c8b-5812bd540e1b";
    private $minimum_sync_interval_in_seconds = 600;
    
    private function default_config(){
        $config = array(
            'oauth' => [
                'callback' => 'http://acaresydney.com.au/',
                'consumer_key' => 'G6AJIRWTH0X3C5SVS3ETZXNFCMDNGG',
                'consumer_secret' => 'LP0PTSBCJLBB4CGYYKOHDXYF2NWXWD',
                'rsa_private_key' => 'file://' . dirname(__FILE__) . '/keys/privatekey.pem',
            ],
        );
        return $config;
    }
    private function office_config(){
        $office_config = [
            'xero'  => [
                // 'payroll_version' =>'1.9',
            ],
            'curl' => [
                CURLOPT_USERAGENT =>'AcareSydneyWebOffice',
            ],
            'oauth' => [
                'callback' => 'http://acaresydney.com.au/',
                'consumer_key' => 'JE4LWKCJ6NHED30RFZWCT7WQYTS8JD',
                'consumer_secret' => 'JXVZAZWKGM7MLUZSVIMK7ZSJE9GNYQ',
                'rsa_private_key' => 'file://' . dirname(__FILE__) . '/keys/privatekey.pem',
            ],
        ];
        return $office_config;
    }
    
    public function __construct(){
       $this->xero = new PrivateApplication($this->office_config());
    }
    
    public function getClients($contact_group_id){
        $xero = $this->xero;
        $cg = $xero->loadByGUID("Accounting\\ContactGroup", $contact_group_id);
        $contacts = $cg->getContacts();
        return $contacts;
    }
    
    public function getContact($id){
        $user = $this->xero->loadByGUID("Accounting\\Contact",$id);
        return $user;
    }
    
    public function getEmployees(){
        $employees = $this->xero->load("PayrollAU\\Employee")
        ->where('EmployeeGroupName="Web-Employee"')
        ->execute();
        return $employees;
    }
    
    public function getEmployee($id){
        $employee = $this->xero->loadByGUID("PayrollAU\\Employee",$id);
        return $employee;
    }
    
    
    
    //
    //sync users to wordpress system
    //does not work for too many users or employees
    public function sync_users($mininterval){
        $this->usage();
        $this->minimum_sync_interval_in_seconds = $mininterval;
        $msg="Sync users with minimum interval set to $mininterval  \n";
        $this->logConsole($msg);
        
        try{
            //$this->sync_clients();
            $this->sync_employees();
        }catch(RateLimitExceededException $e){
            $msg= "Xero API rate limit exceeded, please try again later, existing sync within 600 seconds will by passed automatically\n";
            $this->logConsole($msg);
        }
    }
    private  function sync_clients(){
        $contacts = $this->getClients($this->clientgroup);
        foreach ($contacts as $c){
            $msg = sprintf("SYNC Client name=[%s] {%s} \n",  $c->getName(), $c->getContactID());
            $this->logConsole($msg);
            $this->ensure_contact_exists($c);
        }
    }
    
    private function sync_employees(){
        $employees = $this->getEmployees();
        foreach ( $employees as $e){
            $msg = sprintf("SYNC employee name=[%s %s] {%s} \n",  $e->getFirstName(), $e->getLastName(), $e->getEmployeeID());
            $this->logConsole($msg);
            $this->ensure_staff_exists($e);
        }
    }
    
    private function ensure_contact_exists($contact){
        $login = $contact->getContactID();
        $user = get_user_by('login', $login);
        if ($user === false){
            $xero_contact = $this->getContact($login);
            $args = $this->xero_contact_profile($xero_contact);
            $id = wp_insert_user($args);
            $user = get_user_by('ID', $id);
        }else{//update user
            if ($this->is_too_close_to_sync($user)){
                return;
            }
            $xero_contact = $this->getContact($login);
            $args = $this->xero_contact_profile($xero_contact);
            $args['ID'] = $user->ID;
            unset($args['user_pass']); //we don't change password
            wp_update_user($args);
        }
        $this->mark_updated($user->ID);
    }
    
    private function xero_contact_profile($c){
        $args = [
            'user_login' => $username = $c->getContactID(),
            'user_pass' => md5(uniqid(rand() + time(), true)),
            'display_name' =>$c->getName(),
            'user_email' => $c->getEmailAddress(),
            'first_name' => $c->getFirstName(),
            'last_name' => $c->getLastName(),
            'nickname' => $c->getName(),
            'role' => 'client',
        ];
        return $args;
    }
    
    
    private function ensure_staff_exists($employee)
    {
        $login = $employee->getEmployeeID();
        $user = get_user_by('login', $login);
        if ($user === false){
            $xero_employee = $this->getEmployee($login);
            $args = $this->xero_employee_profile($xero_employee);
            $id = wp_insert_user($args);
            $user = get_user_by('ID', $id);
        }else{
            if ($this->is_too_close_to_sync($user)){
                return;
            }
            $xero_employee = $this->getEmployee($login);
            $args = $this->xero_employee_profile($xero_employee);
            $args['ID'] = $user->ID;
            unset($args['user_pass']);
            wp_update_user($args);
            update_user_meta($user->ID, 'mobile', $args['mobile']);
        }
        $this->mark_updated($user->ID);
    }
    
    private function xero_employee_profile($e){
        $args = [
            'user_login' => $username = $e->getEmployeeID(),
            'user_pass' => md5(uniqid(rand() + time(), true)),
            'display_name' =>$e->getFirstName() . " " . $e->getLastName(),
            'user_email' => $e->getEmail(),
            'first_name' => $e->getFirstName(),
            'last_name' => $e->getLastName(),
            'nickname' => $e->getFirstName(),
            'mobile' => $e->getMobile(),
            'role' => 'staff',
        ];
        return $args;
    }
    
    private function mark_updated($userid){
        update_user_meta($userid, 'lastsync', time());
    }
    
    private function get_last_sync($userid){
        $lastsync = get_user_meta($userid, 'lastsync', true);
        return (int)($lastsync);
    }
    
    private function is_too_close_to_sync($user){
        $userid = $user->ID;
        $lastsync = $this->get_last_sync($user->ID);
        $now = time();
        $diff = $now - (int) $lastsync;
        if ($diff < $this->minimum_sync_interval_in_seconds){
            $msg = sprintf("\tSKIP userid(%d),login=%s,display_name=%s,(lastsync=%d secs ago, mininterval=%d) \n", 
                $user->ID, $user->user_login, $user->display_name, $diff, $this->minimum_sync_interval_in_seconds);
            $this->logConsole($msg);
            return true;
        }
        return false;
    }
    
    private function logConsole($str){
        //if is commandline
        if ( defined( 'WP_CLI' ) && WP_CLI ) {
            echo $str;
        }
    }  
    
    private function usage(){
        $msg = "_____________________________________________\n";
        $msg .= "run this command at public_html/, where wp-config.php exist \n"; 
        $msg .= "wp sync_users --mininterval=6000 \n";
        $msg .= "6000 means those users synced within 6000 seconds will be bypassed \n";
        $msg .= "to sync everything \n";
        $msg .= "wp sync_users --mininterval=0 \n";
        $msg .= "but it may hit XERO rate limit, 60call/sec, 5000/day \n";
        $msg .= "---------------------------------------------\n";
        $this->logConsole($msg);
    }
}