ZillaMetrics

This plugin provides an extensible admin interface for connecting a ZillaMetrics standalone bot to your WordPress site. It ships with four admin pages:
<ul>
<li>Welcome / About — Overview and quick actions.</li>
<li>License — Save and manage your license key.</li>
<li>Activate Script/Bot — Toggle the frontend script/bot and set options.</li>
<li>Preview Bots — List and preview available bots tied to your license.</li>
</ul>
All screens are separated into individual view files so you can easily edit the content to match your product’s exact needs.
Important: This plugin connects to external ZillaMetrics services to provide chat functionality. Please review the “External Services” section below for details on what data is transmitted and to which services.
<h3>External Services</h3>
This plugin relies on external services provided by ZillaMetrics to deliver chat functionality to your website. Below is a detailed description of each service, what data is transmitted, when, and links to relevant terms and privacy policies.
<h3>1. ZillaMetrics Chat Widget Service (CDN)</h3>
What it does: 
The plugin loads the ZillaMetrics chat widget scripts and styles from our Content Delivery Network (CDN) to provide real-time chat functionality on your website. This service automatically delivers the latest version of the chat widget, ensuring you always have access to new features, security updates, and bug fixes without needing to update the plugin.
Resources loaded: 
* <code>https://cdn.zillametrics.com/chat-widget.js</code> – Core chat widget JavaScript 
* <code>https://cdn.zillametrics.com/widget-bundle.js</code> – Chat widget bundle and dependencies 
* <code>https://cdn.zillametrics.com/chat-widget.css</code> – Chat widget styles
When data is sent: 
* Scripts and styles are loaded on every frontend page where the chat widget is enabled 
* Chat widget communicates with ZillaMetrics servers when visitors interact with the chat 
* User interactions, messages, and chat session data are transmitted to provide the chat service
What data is collected: 
* Website visitor information (IP address, user agent, browser information) 
* Chat messages and conversations 
* Page URL where chat is initiated 
* User behavior and interaction data with the chat widget 
* Any information voluntarily provided by visitors through the chat interface
Service Provider: ZillaMetrics Inc. 
Terms of Service: https://zillametrics.com/tos/ 
Privacy Policy: https://zillametrics.com/privacy-policy
<h3>2. ZillaMetrics License Verification API</h3>
What it does: 
The plugin connects to the ZillaMetrics API to verify your license key and retrieve your account information, including available chat bots and configuration settings.
API Endpoint: 
* <code>https://api.zillametrics.com/wp-json/zillametrics/v1/license/verify-basic</code>
When data is sent: 
* When you enter and save your license key in the admin settings 
* Data is only sent from the WordPress admin area, never from the frontend 
* Transmission occurs only when an administrator actively saves the license settings
What data is sent: 
* Your license key 
* Product ID (identifier for this plugin) 
* WordPress site URL (for domain validation) 
* Plugin version number
What data is received: 
* License validation status 
* Available chat bots associated with your account 
* Account plan information 
* License expiration date
Service Provider: ZillaMetrics Inc. 
Terms of Service: https://zillametrics.com/tos/ 
Privacy Policy: https://zillametrics.com/privacy-policy
<h3>Important Privacy Notes</h3>
<ul>
<li>The chat widget service processes visitor data to provide real-time chat functionality</li>
<li>All chat data is stored on ZillaMetrics servers and is subject to ZillaMetrics’ privacy policy</li>
<li>As a site owner, you are responsible for informing your visitors about the use of this chat service in your own privacy policy</li>
<li>No chat functionality is loaded until you activate a valid license</li>
<li>You can disable the chat widget at any time by deactivating your license in the plugin settings</li>
</ul>
By using this plugin, you acknowledge that: 
1. Your website will connect to external ZillaMetrics services 
2. Visitor data will be transmitted to and processed by ZillaMetrics servers 
3. You have reviewed and agree to ZillaMetrics’ Terms of Service and Privacy Policy 
4. You will inform your website visitors about the use of this third-party chat service in your privacy policy

ZillaMetrics Chat

Clean admin UI for integrating ZillaMetrics bot with WordPress. Includes License and Preview Bots screens.

KestutisIT

It is a 3 files library + Visual UI, to validate the purchase codes of your customers, get details about specific Envato user (country, city, total followers, total sales, avatar), get his license purchase and support expiration dates, license type he bought, check for updates of purchased plugins and themes and get the download links for them.
Plus – this library has Envato Item Id search feature by providing plugin’s or theme’s name and author. So – yes, this is a tool you, as a developer / author, have been looking for months.
If you are looking for the library-only version to integrate into your plugin / theme, it’s on GitHub: 
<a href="https://github.com/KestutisIT/EnvatoToolkit" title="Envato Toolkit (Standalone)" rel="nofollow ugc">Envato Toolkit (Standalone)</a>
The main purpose of this plugin is to help you to start much easier without having a headache trying to understand <code>WordPress - Envato Market</code> plugins code, that is the only one built by Envato, and has so complicated and unclear code, that you never get how it works (see example below).
When I tried to create plugin’s <code>[Check for Update]</code> and <code>[Validate Purchase Code]</code> feature-buttons in the plugin myself, and I saw the code of the <code>WordPress - Envato Market</code> plugin, I was shocked how badly it is written and how you should not to code.
For example – you would like to give an error message, if Envato user token is empty, which is a required string, i.e. – <code>pAA0aBCdeFGhiJKlmNOpqRStuVWxyZ44</code>. If you like K.I.S.S., PSR-2, D.R.Y., clean code coding standards and paradigms, you’d probably just have these five lines of code, so that every developer would get it:
<pre><code>$token = get_user_meta(get_current_user_id(), 'envato_token', TRUE);
if($token == "")
{
 return new \WP_Error('api_token_error', __('An API token is required.', 'envato-toolkit'));
}
</code></pre>
Now lets see how the same task traceback looks like in <code>WordPress - Envato Market</code> plugin:
<ol>
<li>
<code>[Api.php -> request(..)]</code> Check if the token is empty:
<pre><code>if ( empty( $token ) )
{
 return new WP_Error( 'api_token_error', __( 'An API token is required.', 'envato-market' ) );
}
</code></pre>
</li>
<li>
<code>[Api.php -> request(..)]</code> Parse it from another string:
<pre><code>$token = trim( str_replace( 'Bearer', '', $args['headers']['Authorization'] ) );
</code></pre>
</li>
<li>
<code>[Api.php -> request(..)]</code> Parse it one more time – this time from arguments array:
<pre><code>public function request( $url, $args = array() ) {
 $defaults = array(
 'timeout' => 20,
 );
 $args = wp_parse_args( $args, $defaults );
}
</code></pre>
</li>
<li>
<code>[Api.php -> download(..)]</code> Transfer the token variable one more time – this time via params:
<pre><code>class Envato_Market_API {
 public function download( $id, $args = array() ) {
 $url = 'https://api.envato.com/v2/market/buyer/download?item_id=' . $id . '&shorten_url=true';
 return $this->request( $url, $args );
 }
}
</code></pre>
</li>
<li>
<code>[admin.php -> maybe_deferred_download(..)]</code> Pass it again – this time get it to args array from another method call:
<pre><code>function maybe_deferred_download( $options ) {
 $args = $this->set_bearer_args();
 $options['package'] = envato_market()->api()->download( $vars['item_id'], $args );
 return $options;
}
</code></pre>
</li>
<li>
<code>[admin.php -> set_bearer_args(..)]</code> Wrap the token into multi-dimensional string array:
<pre><code>$args = array(
 'headers' => array(
 'Authorization' => 'Bearer ' . $token,
 ),
);
</code></pre>
</li>
<li>
<code>[admin.php -> set_bearer_args(..)]</code> Pass the wrapped token one more time – this time get it from get_option:
<pre><code>foreach ( envato_market()->get_option( 'items', array() ) as $item ) {
 if ( $item['id'] === $id ) {
 $token = $item['token'];
 break;
 }
}
</code></pre>
</li>
<li>
<code>[admin.php -> get_option(..)]</code> So what’s in this <code>get_option</code>? – Correct, another call to another method – <code>get_options()</code>:
<pre><code>public function get_option( $name, $default = '' ) {
 $options = self::get_options();
 $name = self::sanitize_key( $name );
 return isset( $options[ $name ] ) ? $options[ $name ] : $default;
}
</code></pre>
</li>
<li>
<code>[admin.php -> get_options()]</code> Finally, after almost 10 steps in the tree, we are finally getting the original 
WordPress method call, but now I’m getting confused again – what is that <code>option_name</code> variable here:
<pre><code>public function get_options() {
 return get_option( $this->option_name, array() );
}
</code></pre>
</li>
<li>
<code>[envato-market.php -> init_globals()]</code> Here is it is – the <code>option name</code> key name is… Oh wait… 
No it is not here it. It is equals to another variable, who is is put 
in another clean-up function – look like I’m keep seeing this for the 2 time in the tree – the sanitization of sanitization:
<pre><code>$this->option_name = self::sanitize_key( $this->slug );
</code></pre>
</li>
<li>
<code>[envato-market.php -> init_globals()]</code> So the <code>option name</code> key name is the name of <code>$this->slug</code>. 
Now lets see what is the value of <code>$this->slug</code>:
<pre><code>$this->slug = 'envato-market';
</code></pre>
</li>
</ol>
So it takes eleven (!) steps to understand one variable. And the whole code of that plugin is like that. The example above was the headache I had, until I realized that I must write a new Envato API Management Toolkit, instead of trying to use what Envato is giving, because otherwise I won’t get anything working ever.
And, I believe, that many other developers had the same issue when tried to create update check feature for their plugins or themes.
So instead of using that library for myself, I decided that I want to help all these developers to save their time, and I’m sharing this code with you. I’m releasing it under MIT license, which allows you to use this code in your plugin without any restrictions for both – free and commercial use.
Plus – I’m giving a promise to you, that this plugin is and will always be 100% free, without any ads, ‘Subscribe’, ‘Follow us’, ‘Check our page’, ‘Get Pro Version’ or similar links.
If you created in hi-quality code a valuable additional functionality to the library and you want to share it with everyone – I’m open here to support your efforts, and add your code to the plugin’s library, so that we all together make this plugin better for authors – the better is the plugin, the better plugins authors will make for their customers. The better quality products we will have on the internet, the happier people will be all over the world.
Finally – the code is poetry – the better is the plugin, the happier is the world.
The pseudo-code of example output of the plugin is this:
<pre><code>Details about you:
----------------------------------------------------------
List of all different plugins you bought:
<?php foreach($plugins AS $pluginId => $plugin): ?>
 <?='Plugin Id: '.$pluginId.', Name: '.$plugin['name'];?>, Licenses:
 <?php foreach($plugin['licenses'] AS $license): ?>
 Code: <?=$license['purchase_code'];?>,
 License: <?=$license['license'];?>,
 Purchased: <?=$license['license_purchase_date'];?> <?=$license['license_purchase_time'];?>,
 Expires: <?=$license['support_expiration_date'];?> <?=$license['support_expiration_time'];?>,
 Support Status: <?=$license['support_active'];?>
 <?php endforeach; ?>
<?php endforeach; ?>

List of all different themes you bought:
<?php foreach($themes AS $themeId => $theme): ?>
 <?='Theme Id: '.$themeId.', Name: '.$theme['name'];?>, Licenses:
 <?php foreach($theme['licenses'] AS $license): ?>
 Code: <?=$license['purchase_code'];?>,
 License: <?=$license['license'];?>,
 Purchased: <?=$license['license_purchase_date'];?> <?=$license['license_purchase_time'];?>,
 Expires: <?=$license['support_expiration_date'];?> <?=$license['support_expiration_time'];?>,
 Status: <?=$license['support_active'] == 1 ? "Supported" : "Support Expired";?>
 <?php endforeach; ?>
<?php endforeach; ?>

Your summary:
Your location is <?=$authorCity;?>, <?=$authorCountry;?>.
You've sold your items <?=$authorSales;?> times and you have <?=$authorFollowers;?> followers on Envato.

1. Your Customer's License Details
----------------------------------------------------------
Purchase Code: <?=$targetPurchaseCode;?>
Is Valid License: <?=$isValidTargetLicense ? 'Yes' : 'No';?>
Buyer Username: <?=$targetLicenseBuyer;?>
License Type: <?=$targetLicenseType;?>
Purchased At: <?=$targetLicensePurchasedAt;?>
Supported Until: <?=$targetLicenseSupportedUntil;?>
Support Status: <?=$targetLicenseSupportActive == 1 ? "Supported" : "Support Expired";?>

2. Details About Target Envato User - <?=$targetUsername;?>
----------------------------------------------------------
<?=$targetUsername;?> is located in <?=$targetUserCity;?>, <?=$targetUserCountry;?>.
He sold his items <?=$targetUserSales;?> times and has <?=$targetUserFollowers;?> followers on Envato.

3. Status of Purchased Plugin ID - <?=$targetPluginId;?>
----------------------------------------------------------
Plugin Name: <?=$nameOfTargetPluginId;?>
Plugin Update Available: <?=$pluginUpdateAvailable ? 'Yes' : 'No';?>
Installed Plugin Version: <?=$installedPluginVersion;?>
Available Plugin Version: <?=$availablePluginVersion;?>
Plugin Update Download URL:
<a href="<?=$pluginUpdateDownloadUrl;?>" target="_blank" title="Download newest version">Download newest version</a>

4. Status of Purchased Theme ID - <?=$targetThemeId;?>:
----------------------------------------------------------
Theme Name: <?=$nameOfTargetThemeId;?>
Theme Update Available: <?=$themeUpdateAvailable ? 'Yes' : 'No';?>
Installed Theme Version: <?=$installedThemeVersion;?>
Available Theme Version: <?=$availableThemeVersion;?>
Theme Update Download URL:
<a href="<?=$themeUpdateDownloadUrl;?>" target="_blank" title="Download newest version">Download newest version</a>

5. Envato Item Id of Purchased Plugin
----------------------------------------------------------
Searched for Name: <?=$targetPluginName;?>
Searched for Author: <?=$targetPluginAuthor;?>
Found Plugin Id: <?=$foundPluginId;?>

6. Envato Item Id of Purchased Theme
----------------------------------------------------------
Searched for Name: <?=$targetThemeName;?>
Searched for Author: <?=$targetThemeAuthor;?>
Found Theme Id: <?=$foundThemeId;?>
</code></pre>
And the example input of the output above, it this:
<pre><code>$objToolkit = new EnvatoAPIManager($toolkitSettings);

// Details about you
$purchasedPlugins = $objToolkit->getPurchasedPluginsWithDetails();
$plugins = array();
foreach($purchasedPlugins AS $pluginId => $purchasedPlugin)
{
 $purchasedPlugin['licenses'] = $objToolkit->getLicensesByItemId($pluginId);
 $plugins[$pluginId] = $purchasedPlugin;
}

$purchasedThemes = $objToolkit->getPurchasedThemesWithDetails();
$themes = array();
foreach($purchasedThemes AS $themeId => $purchasedTheme)
{
 $purchasedTheme['licenses'] = $objToolkit->getLicensesByItemId($themeId);
 $themes[$themeId] = $purchasedTheme;
}

$authorDetails = $objToolkit->getUserDetails($sanitizedEnvatoUsername);
// View vars
$view->plugins = $plugins;
$view->themes = $themes;
if($authorDetails != FALSE)
{
 $view->authorCity = $authorDetails['city'];
 $view->authorCountry = $authorDetails['country'];
 $view->authorSales = $authorDetails['sales'];
 $view->authorFollowers = $authorDetails['followers'];
} else
{
 $view->authorCity = '';
 $view->authorCountry = '';
 $view->authorSales = 0;
 $view->authorFollowers = 0;
}

// 1. Details About Target Purchase Code
$targetLicenseDetails = $objToolkit->getLicenseDetails($sanitizedTargetPurchaseCode);
// View vars
$view->targetPurchaseCode = esc_html($sanitizedTargetPurchaseCode); // Ready for print
$view->isValidTargetLicense = $objToolkit->isValidLicense($sanitizedTargetPurchaseCode);
$view->targetLicenseBuyer = $targetLicenseDetails['buyer_username'];
$view->targetLicense = $targetLicenseDetails['license'];
$view->targetLicensePurchasedAt = $targetLicenseDetails['license_purchase_date'].' '.$targetLicenseDetails['license_purchase_time'];
$view->targetLicenseSupportedUntil = $targetLicenseDetails['support_expiration_date'].' '.$targetLicenseDetails['support_expiration_time'];
$view->targetLicenseSupportActive = $targetLicenseDetails['support_active'];

// 2. Details About Target Envato User
$targetUserDetails = $objToolkit->getUserDetails($sanitizedTargetUsername);
// View vars
$view->targetUsername = esc_html($sanitizedTargetUsername); // Ready for print
$view->targetUserCity = $targetUserDetails['city'];
$view->targetUserCountry = $targetUserDetails['country'];
$view->targetUserSales = $targetUserDetails['sales'];
$view->targetUserFollowers = $targetUserDetails['followers'];

// 3. Status of Purchased Plugin ID
$availablePluginVersion = $objToolkit->getAvailableVersion($sanitizedTargetPluginId);
$pluginUpdateAvailable = version_compare($sanitizedInstalledPluginVersion, $availablePluginVersion, '<');
// View vars
$view->targetPluginId = intval($sanitizedTargetPluginId); // Ready for print
$view->installedPluginVersion = esc_html($sanitizedInstalledPluginVersion); // Ready for print
$view->nameOfTargetPluginId = esc_html($objToolkit->getItemName($sanitizedTargetPluginId));
$view->availablePluginVersion = $availablePluginVersion;
$view->pluginUpdateAvailable = $pluginUpdateAvailable;
$view->pluginUpdateDownloadUrl = $pluginUpdateAvailable ? $objToolkit->getDownloadUrlIfPurchased($sanitizedTargetPluginId) : '';

// 4. Status of Purchased Theme ID
$availableThemeVersion = $objToolkit->getAvailableVersion($sanitizedTargetThemeId);
$themeUpdateAvailable = version_compare($sanitizedInstalledThemeVersion, $availableThemeVersion, '<');
// View vars
$view->targetThemeId = intval($sanitizedTargetThemeId); // Ready for print
$view->installedThemeVersion = esc_html($sanitizedInstalledThemeVersion); // Ready for print
$view->nameOfTargetThemeId = esc_html($objToolkit->getItemName($sanitizedTargetThemeId));
$view->availableThemeVersion = $availableThemeVersion;
$view->themeUpdateAvailable = $themeUpdateAvailable;
$view->themeUpdateDownloadUrl = $themeUpdateAvailable ? $objToolkit->getDownloadUrlIfPurchased($sanitizedTargetThemeId) : '';

// 5. Envato Item Id of Purchased Plugin
$view->targetPluginName = esc_html($sanitizedTargetPluginName); // Ready for print
$view->targetPluginAuthor = esc_html($sanitizedTargetPluginAuthor); // Ready for print
$view->foundPluginId = $objToolkit->getItemIdByPluginAndAuthorIfPurchased($sanitizedTargetPluginName, $sanitizedTargetPluginAuthor);

// 6. Envato Item Id of Purchased Theme
$view->targetThemeName = esc_html($sanitizedTargetThemeName); // Ready for print
$view->targetThemeAuthor = esc_html($sanitizedTargetThemeAuthor); // Ready for print
$view->foundThemeId = $objToolkit->getItemIdByThemeAndAuthorIfPurchased($sanitizedTargetThemeName, $sanitizedTargetThemeAuthor);
</code></pre>

Envato Toolkit

I hope this will help authors to discover the toolkit quicker, and things like version checking and purchase code validation become more common used and more standardized.

Amazing tool for authors to verify purchases and check updates

Validate purchase code, check for item update & support expiration, download newest version, lookup for user details, search for Envato item id & more

ZillaMetrics Chat vs Envato Toolkit