whmcsKerioEmail/app/Libs/Metrics/MyMetricProvider.php

<?php

namespace ThurData\Servers\KerioEmail\App\Libs\Metrics;

use ThurData\Servers\HetznerVps\App\Libs\HetznerVps\Api;
use ThurData\Servers\HetznerVps\App\Libs\HetznerVps\Api\Constants;
use ThurData\Servers\KerioEmail\App\Helpers\KerioManager;
use ThurData\Servers\KerioEmail\App\Enums\Size;
use mysql_xdevapi\DocResult;
use WHMCS\UsageBilling\Contracts\Metrics\MetricInterface;
use WHMCS\UsageBilling\Contracts\Metrics\ProviderInterface;
use WHMCS\UsageBilling\Metrics\Metric;
use WHMCS\UsageBilling\Metrics\Units\WholeNumber;
use WHMCS\UsageBilling\Metrics\Usage;
use WHMCS\UsageBilling\Metrics\Units\GigaBytes;
use ThurData\Servers\KerioEmail\Api\KerioWhmcs;

class MyMetricProvider implements ProviderInterface
{
    private $moduleParams = [];
    public function __construct($moduleParams)
    {
        $this->moduleParams = $moduleParams;
    }

    public function metrics()
    {
        return [
            new Metric(
                'mailboxes',
                'Email Accounts',
                MetricInterface::TYPE_SNAPSHOT
            ),
            new Metric(
                'aliases',
                'Email Aliases',
                MetricInterface::TYPE_SNAPSHOT
            ),
            new Metric(
                'distributionLists',
                'Distribution Lists',
                MetricInterface::TYPE_SNAPSHOT
            ),
            new Metric(
                'domainAliases',
                'Domain Aliases',
                MetricInterface::TYPE_SNAPSHOT
            ),
            new Metric(
                'storage',
                'Storage',
                MetricInterface::TYPE_SNAPSHOT,
                new GigaBytes()
            )
        ];
    }

    public function usage()
    {
        $api = new KerioWhmcs('whmcsKerioEmail', 'Thurdata', '1.0');
        try {
            $api->login($this->moduleParams['serverhostname'], $this->moduleParams['serverusername'], $this->moduleParams['serverpassword']);
            $domains = $api->getDomains(['id','name','aliasList']);
        } catch (KerioApiException $error) {
            logModuleCall(
                'kerioEmail',
                __FUNCTION__,
                $error,
                'Debug Error',
                $error->getMessage()
            );
            return ['error' => $error->getMessage()];
        }
        $usage = [];

        foreach ($domains as $domain)
        {
            $domainName = $domain['name'];
            $domainID = $domain['id'];
            $countOfDomainAliases = count($domain['aliasList']);
            try
            {
                $fields = array(
					'loginName',
					'fullName',
					'consumedSize'
                );
                $mailboxes = $api->getUsers($fields,$domainID);
                $countOfMailboxes = count($mailboxes);
                $totalUsage = 0;
                if ($countOfMailboxes > 0) {
                    foreach ($mailboxes as $mailboxe) {
                        switch($mailboxe['consumedSize']['units']) {
                            case 'Bytes' :
                                $usage = $mailboxe['consumedSize']['value']/1024/1024;
                                break;
                            case 'KiloBytes' :
                                $usage = $mailboxe['consumedSize']['value']/1024;
                                break;
                            case 'MegaBytes' :
                                $usage = $mailboxe['consumedSize']['value'];
                                break;
                            case 'GigaBytes' :
                                $usage = $mailboxe['consumedSize']['value']*1024;
                                break;
                        }
                        $totalUsage += $usage;
                    }
                }
               $storage = $totalUsage == 0 ? 0 : round($totalUsage);
            } catch (KerioApiException $error) {
                logModuleCall(
                    'kerioEmail',
                    __FUNCTION__,
                    $error,
                    'Debug Error',
                    $error->getMessage()
                );
                return ['error' => $error->getMessage()];
            }
            try
            {
                $fields = array(
                    "id",
                    "name");
                $mailingLists = $api->getMailingLists($fields,$domainID);
                $countOfDistributionList = count($mailingLists);
            } catch (KerioApiException $error) {
                logModuleCall(
                    'kerioEmail',
                    __FUNCTION__,
                    $error,
                    'Debug Error',
                    $error->getMessage()
                );
                return ['error' => $error->getMessage()];
            }
            try
            {
                $fields = array(
                    "id",
                    "name");
                $aliases = $api->getAliases($fields,$domainID);
                $countOfEmailAliases = count($aliases);
            } catch (KerioApiException $error) {
                logModuleCall(
                    'kerioEmail',
                    __FUNCTION__,
                    $error,
                    'Debug Error',
                    $error->getMessage()
                );
                return ['error' => $error->getMessage()];
            }

            $domainData = [
                'mailboxes' => $countOfMailboxes,
                'distributionLists' => $countOfDistributionList,
                'aliases' => $countOfEmailAliases,
                'domainAliases' => $countOfDomainAliases,
                'storage' => $storage,
            ];

            $usage[$domainName] = $this->wrapUserData($domainData);

        }
        $api->logout();
        return $usage;
    }

    public function tenantUsage($tenant)
    {
        $api = new KerioWhmcs('whmcsKerioEmail', 'Thurdata', '1.0');
        try {
            $api->login($this->moduleParams['serverhostname'], $this->moduleParams['serverusername'], $this->moduleParams['serverpassword']);
            $domains = $api->getDomains(['id','name','aliasList']);
        } catch (KerioApiException $error) {
            logModuleCall(
                'kerioEmail',
                __FUNCTION__,
                $error,
                'Debug Error',
                $error->getMessage()
            );
            return ['error' => $error->getMessage()];
        }
        $usage = [];

        foreach ($domains as $domain)
        {
            $domainName = $domain['name'];
            $domainID = $domain['id'];
            $countOfDomainAliases = count($domain['aliasList']);
            try
            {
                $fields = array(
					'loginName',
					'fullName',
					'consumedSize'
                );
                $mailboxes = $api->getUsers($fields,$domainID);
                $countOfMailboxes = count($mailboxes);
                $totalUsage = 0;
                if ($countOfMailboxes > 0) {
                    foreach ($mailboxes as $mailboxe) {
                        switch($mailboxe['consumedSize']['units']) {
                            case 'Bytes' :
                                $usage = $mailboxe['consumedSize']['value']/1024/1024;
                                break;
                            case 'KiloBytes' :
                                $usage = $mailboxe['consumedSize']['value']/1024;
                                break;
                            case 'MegaBytes' :
                                $usage = $mailboxe['consumedSize']['value'];
                                break;
                            case 'GigaBytes' :
                                $usage = $mailboxe['consumedSize']['value']*1024;
                                break;
                        }
                        $totalUsage += $usage;
                    }
                }
               $storage = $totalUsage == 0 ? 0 : round($totalUsage);
            } catch (KerioApiException $error) {
                logModuleCall(
                    'kerioEmail',
                    __FUNCTION__,
                    $error,
                    'Debug Error',
                    $error->getMessage()
                );
                return ['error' => $error->getMessage()];
            }
            try
            {
                $fields = array(
                    "id",
                    "name");
                $mailingLists = $api->getMailingLists($fields,$domainID);
                $countOfDistributionList = count($mailingLists);
            } catch (KerioApiException $error) {
                logModuleCall(
                    'kerioEmail',
                    __FUNCTION__,
                    $error,
                    'Debug Error',
                    $error->getMessage()
                );
                return ['error' => $error->getMessage()];
            }
            try
            {
                $fields = array(
                    "id",
                    "name");
                $aliases = $api->getAliases($fields,$domainID);
                $countOfEmailAliases = count($aliases);
            } catch (KerioApiException $error) {
                logModuleCall(
                    'kerioEmail',
                    __FUNCTION__,
                    $error,
                    'Debug Error',
                    $error->getMessage()
                );
                return ['error' => $error->getMessage()];
            }

            $domainData = [
                'mailboxes' => $countOfMailboxes,
                'distributionLists' => $countOfDistributionList,
                'aliases' => $countOfEmailAliases,
                'domainAliases' => $countOfDomainAliases,
                'storage' => $storage,
            ];

            $usage[$domainName] = $this->wrapUserData($domainData);

        }
        $api->logout();
        return $usage;
    }

    private function wrapUserData($data)
    {
        $wrapped = [];
        foreach ($this->metrics() as $metric) {
            $key = $metric->systemName();
            if ($data[$key]) {
                $value = $data[$key];
                $metric = $metric->withUsage(
                    new Usage($value)
                );
            }

            $wrapped[] = $metric;
        }

        return $wrapped;
    }

    private function getAccounts($tenant)
    {
        $accounts =(new KerioManager())
            ->getApiByServer($this->moduleParams['serverid'])
            ->soap
            ->repository()
            ->accounts()
            ->getByDomainName($tenant);

        return $accounts;
    }

    private function getDomainAliases($tenant)
    {
        $domainAliases =(new KerioManager())
            ->getApiByServer($this->moduleParams['serverid'])
            ->soap
            ->repository()
            ->domains
            ->getAliases($tenant);

        return $domainAliases;
    }

    private function getDomainUsage($tenant)
    {
        $accounts =(new KerioManager())
            ->getApiByServer($this->moduleParams['serverid'])
            ->soap
            ->repository()
            ->accounts
            ->getUsages($tenant);

        $totalUsage = 0;
        foreach ($accounts as $account)
        {
            $usage = $account->getUsed();
            $totalUsage += $usage;
        }

        return $totalUsage;
    }

    private function getDistributionList($tenant)
    {
        $distributionList =(new KerioManager())
            ->getApiByServer($this->moduleParams['serverid'])
            ->soap
            ->repository()
            ->lists
            ->getAllDistributionListsByDomain($tenant);

        return $distributionList;
    }

}