I have PHP IMAP used for the following tasks:
- Removing old letters from mailboxes . Unfortunately, in the control panel of the corporate G Suite account, you can only configure the period for deleting messages from all mailboxes of the organization after N days after receipt. I, however, need to delete letters only in specified mailboxes and after a specified different number of days after receipt.
- Filtering, parsing and marking letters . A lot of letters are sent from our site in automatic mode, some of which do not reach the addressees, about which, accordingly, reports come. It is necessary to catch these reports, disassemble, find a client by email and form a human-readable letter for the manager, so that he can contact the client and clarify the relevance of the email address.
We will solve these two tasks using the Gmail API in this article (and at the same time disable access for unsafe applications in the mailbox settings, which was enabled for PHP IMAP to work, and, in fact, will stop working on a terrible day in February 2021). We will use the so-called service account of the Gmail application, which, with appropriate configuration, makes it possible to connect to all mailboxes of the organization and perform any actions in them.
1. Create a project in the Google API developer console
With the help of this project, we will carry out API interaction with Gmail, and in it we will create the same service account.
To create a project:
- Go to the Google API developer console and log in as the G Suite administrator (well, or who is your user there with all rights)
- We are looking for the "Create Project" button.
I found here:
And then here:
Fill in the project name and save:
Project creation
- Go to the project and click the "Enable API and Services" button:
Enable API and services
Choosing the Gmail API
2. Create and configure a service account
To do this, you can use the official manual or continue reading:
- Go to our added Gmail API, click the "Create credentials" button and select "Service account":
Service account creation
Fill in something and click "Create":
Service account details
Everything else can be left blank:
Access rights for the service account
- , . G Suite, « — API».
API
- « »:
«», « » , « OAuth» — :
- https://mail.google.com/ -
- https://www.googleapis.com/auth/gmail.modify -
- https://www.googleapis.com/auth/gmail.readonly -
- https://www.googleapis.com/auth/gmail.metadata -
- « G Suite»:
And also fill in the name of your product in the field below.
- Now you need to create a service account key: this is a file that should be available in your application. He, in fact, will be used for authorization.
To do this, from the "Credentials" page of your project, follow the link "Manage service accounts":
Credentials
and select "Actions - Create Key", type: JSON:
Service account management
After that, a key file will be generated and downloaded to your computer, which must be placed in your project and given access to when you call the Gmail API.
This completes the configuration of the Gmail API, then there will be a little of my cocoa code, in fact, implementing the functions that have so far been solved by the IMAP PHP extension.
3. Writing the code
There is quite good official documentation ( click and click ) on the Gmail API , which I used. But since I undertook to write a detailed manual, then I will attach my own cocoa code.
So, first of all, we install the Google Client Library (apiclient) using composer:
composer require google/apiclient
(At first, as a true literary expert, I installed version 2.0 of the api-client, as indicated in PHP Quickstart , but at the first start, all sorts of vornings and alarms fell on PHP 7.4 , so I do not advise you to do the same)
Then, based on examples from the official documentation, we write our own class for working with Gmail, not forgetting to specify the service account key file:
Class for working with Gmail
<?php
// Gmail
class GmailAPI
{
private $credentials_file = __DIR__ . '/../Gmail/credentials.json'; //
// ---------------------------------------------------------------------------------------------
/**
* Google_Service_Gmail Authorized Gmail API instance
*
* @param string $strEmail
* @return Google_Service_Gmail Authorized Gmail API instance
* @throws Exception
*/
function getService(string $strEmail){
//
try{
$client = new Google_Client();
$client->setAuthConfig($this->credentials_file);
$client->setApplicationName('My Super Project');
$client->setScopes(Google_Service_Gmail::MAIL_GOOGLE_COM);
$client->setSubject($strEmail);
$service = new Google_Service_Gmail($client);
}catch (Exception $e) {
throw new \Exception(' getService: '.$e->getMessage());
}
return $service;
}
// ---------------------------------------------------------------------------------------------
/**
* ID
*
* @param Google_Service_Gmail $service Authorized Gmail API instance.
* @param string $strEmail
* @param array $arrOptionalParams
* Gmail after: 2020/08/20 in:inbox label:
* q $opt_param
* @return array ID array('arrErrors' => $arrErrors),
* @throws Exception
*/
function listMessageIDs(Google_Service_Gmail $service, string $strEmail, array $arrOptionalParams = array()) {
$arrIDs = array(); // ID
$pageToken = NULL; //
$messages = array(); //
//
$opt_param = array();
// , Gmail q
if (count($arrOptionalParams)) $opt_param['q'] = str_replace('=', ':', http_build_query($arrOptionalParams, null, ' '));
// , ,
do {
try {
if ($pageToken) {
$opt_param['pageToken'] = $pageToken;
}
$messagesResponse = $service->users_messages->listUsersMessages($strEmail, $opt_param);
if ($messagesResponse->getMessages()) {
$messages = array_merge($messages, $messagesResponse->getMessages());
$pageToken = $messagesResponse->getNextPageToken();
}
} catch (Exception $e) {
throw new \Exception(' listMessageIDs: '.$e->getMessage());
}
} while ($pageToken);
// ID
if (count($messages)) {
foreach ($messages as $message) {
$arrIDs[] = $message->getId();
}
}
return $arrIDs;
}
// ---------------------------------------------------------------------------------------------
/**
* ID batchDelete
*
* @param Google_Service_Gmail $service Authorized Gmail API instance.
* @param string $strEmail
* @param array $arrIDs ID listMessageIDs
* @throws Exception
*/
function deleteMessages(Google_Service_Gmail $service, string $strEmail, array $arrIDs){
// 1000 , batchDelete
$arrParts = array_chunk($arrIDs, 999);
if (count($arrParts)){
foreach ($arrParts as $arrPartIDs){
try{
//
$objBatchDeleteMessages = new Google_Service_Gmail_BatchDeleteMessagesRequest();
//
$objBatchDeleteMessages->setIds($arrPartIDs);
//
$service->users_messages->batchDelete($strEmail,$objBatchDeleteMessages);
}catch (Exception $e) {
throw new \Exception(' deleteMessages: '.$e->getMessage());
}
}
}
}
// ---------------------------------------------------------------------------------------------
/**
* get
*
* @param Google_Service_Gmail $service Authorized Gmail API instance.
* @param string $strEmail
* @param string $strMessageID ID
* @param string $strFormat The format to return the message in.
* Acceptable values are:
* "full": Returns the full email message data with body content parsed in the payload field; the raw field is not used. (default)
* "metadata": Returns only email message ID, labels, and email headers.
* "minimal": Returns only email message ID and labels; does not return the email headers, body, or payload.
* "raw": Returns the full email message data with body content in the raw field as a base64url encoded string; the payload field is not used.
* @param array $arrMetadataHeaders When given and format is METADATA, only include headers specified.
* @return object Message
* @throws Exception
*/
function getMessage(Google_Service_Gmail $service, string $strEmail, string $strMessageID, string $strFormat = 'full', array $arrMetadataHeaders = array()){
$arrOptionalParams = array(
'format' => $strFormat // ,
);
// - metadata,
if (($strFormat == 'metadata') and count($arrMetadataHeaders))
$arrOptionalParams['metadataHeaders'] = implode(',',$arrMetadataHeaders);
try{
$objMessage = $service->users_messages->get($strEmail, $strMessageID,$arrOptionalParams);
return $objMessage;
}catch (Exception $e) {
throw new \Exception(' getMessage: '.$e->getMessage());
}
}
// ---------------------------------------------------------------------------------------------
/**
* ,
*
* @param Google_Service_Gmail $service Authorized Gmail API instance.
* @param string $strEmail
* @return object $objLabels - -
* @throws Exception
*/
function listLabels(Google_Service_Gmail $service, string $strEmail){
try{
$objLabels = $service->users_labels->listUsersLabels($strEmail);
return $objLabels;
}catch (Exception $e) {
throw new \Exception(' listLabels: '.$e->getMessage());
}
}
// ---------------------------------------------------------------------------------------------
/**
* ()
*
* @param Google_Service_Gmail $service Authorized Gmail API instance.
* @param string $strEmail
* @param string $strMessageID ID
* @param array $arrAddLabelIds ID ,
* @param array $arrRemoveLabelIds ID ,
* @return object Message -
* @throws Exception
*/
function modifyLabels(Google_Service_Gmail $service, string $strEmail, string $strMessageID, array $arrAddLabelIds = array(), array $arrRemoveLabelIds = array()){
try{
$objPostBody = new Google_Service_Gmail_ModifyMessageRequest();
$objPostBody->setAddLabelIds($arrAddLabelIds);
$objPostBody->setRemoveLabelIds($arrRemoveLabelIds);
$objMessage = $service->users_messages->modify($strEmail,$strMessageID,$objPostBody);
return $objMessage;
}catch (Exception $e) {
throw new \Exception(' modifyLabels: '.$e->getMessage());
}
}
// ---------------------------------------------------------------------------------------------
}
Whenever we interact with Gmail, the first thing we do is call the getService ($ strEmail) function of the GmailAPI class, which returns an "authorized" object for working with the $ strEmail mailbox. Further, this object is already passed to any other function to directly perform the actions we need. All other functions in the GmailAPI class already perform specific tasks:
- listMessageIDs - finds messages according to the specified criteria and returns their ID (the search string passed to the listUsersMessages Gmail API function must be similar to the search string in the mailbox web interface),
- deleteMessages - deletes messages with IDs passed to it (the batchDelete API Gmail function deletes no more than 1000 messages in one pass, so I had to split the array of IDs passed to the function into several arrays of 999 letters each and perform the deletion several times),
- getMessage - gets all information about the message with the ID passed to it,
- listLabels - returns a list of flags in the mailbox (I used it to get the ID of the flag that was originally created in the mailbox web interface and is assigned to the desired messages)
- modifyLabels - add or remove flags to the message
Next, we have the task of deleting old letters in various mailboxes. At the same time, we consider old letters received their number of days ago for each mailbox. To accomplish this task, we write the following script, which is run daily by cron:
Removing old emails
<?php
/**
* Gmail
*
*/
require __DIR__ .'/../general/config/config.php'; //
require __DIR__ .'/../vendor/autoload.php'; //
//
$arrMailBoxesForClean = array(
'a@domain.com' => 30,
'b@domain.com' => 30,
'c@domain.com' => 7,
'd@domain.com' => 7,
'e@domain.com' => 7,
'f@domain.com' => 1
);
$arrErrors = array(); //
$objGmailAPI = new GmailAPI(); // GMail
// ,
foreach ($arrMailBoxesForClean as $strEmail => $intDays) {
try{
//
$service = $objGmailAPI->getService($strEmail);
//
$arrParams = array('before' => date('Y/m/d', (time() - 60 * 60 * 24 * $intDays)));
// ,
$arrIDs = $objGmailAPI->listMessageIDs($service,$strEmail,$arrParams);
// ID $arrIDs
if (count($arrIDs)) $objGmailAPI->deleteMessages($service,$strEmail,$arrIDs);
//
unset($service,$arrIDs);
}catch (Exception $e) {
$arrErrors[] = $e->getMessage();
}
}
if (count($arrErrors)){
$strTo = 'my_email@domain.com';
$strSubj = ' ';
$strMessage = ' :'.
'<ul><li>'.implode('</li><li>',$arrErrors).'</li></ul>'.
'<br/>URL: '.filter_input(INPUT_SERVER, 'REQUEST_URI', FILTER_SANITIZE_URL);
$objMailSender = new mailSender();
$objMailSender->sendMail($strTo,$strSubj,$strMessage);
}
The script connects to each specified mailbox, selects old letters and deletes them.
The task of generating reports for the manager about undelivered emails based on automatic reports is solved by the following script:
Filtering and marking emails
<?php
/*
* a@domain.com
* , : : mailer-daemon@googlemail.com
* . , b@domain.com
*
*/
require __DIR__ .'/../general/config/config.php'; //
require __DIR__ .'/../vendor/autoload.php'; //
$strEmail = 'a@domain.com';
$strLabelID = 'Label_2399611988534712153'; // reportProcessed -
//
$arrParams = array(
'from' => 'mailer-daemon@googlemail.com', //
'in' => 'inbox', //
'after' => date('Y/m/d', (time() - 60 * 60 * 24)), //
'has' => 'nouserlabels' //
);
$arrErrors = array(); //
$objGmailAPI = new GmailAPI(); // GMail
$arrClientEmails = array(); // ,
try{
//
$service = $objGmailAPI->getService($strEmail);
// ,
$arrIDs = $objGmailAPI->listMessageIDs($service,$strEmail, $arrParams);
// 'X-Failed-Recipients', ,
if (count($arrIDs)){
foreach ($arrIDs as $strMessageID){
//
$objMessage = $objGmailAPI->getMessage($service,$strEmail,$strMessageID,'metadata',array('X-Failed-Recipients'));
//
$arrHeaders = $objMessage->getPayload()->getHeaders();
//
foreach ($arrHeaders as $objMessagePartHeader){
if ($objMessagePartHeader->getName() == 'X-Failed-Recipients'){
$strClientEmail = mb_strtolower(trim($objMessagePartHeader->getValue()), 'UTF-8');
if (!empty($strClientEmail)) {
if (!in_array($strClientEmail, $arrClientEmails)) $arrClientEmails[] = $strClientEmail;
}
// reportProcessed,
$objGmailAPI->modifyLabels($service,$strEmail,$strMessageID,array($strLabelID));
}
}
}
}
unset($service,$arrIDs,$strMessageID);
}catch (Exception $e) {
$arrErrors[] = $e->getMessage();
}
// , ,
if (count($arrClientEmails)) {
$objClients = new clients();
// email
$arrAllClientsEmails = $objClients->getAllEmails();
foreach ($arrClientEmails as $strClientEmail){
$arrUsages = array();
foreach ($arrAllClientsEmails as $arrRow){
if (strpos($arrRow['email'], $strClientEmail) !== false) {
$arrUsages[] = ' email "<a href="'.MANAGEURL.'?m=admin&sm=clients&edit='.$arrRow['s_users_id'].'">'.$arrRow['name'].'</a>"';
}
if (strpos($arrRow['email2'], $strClientEmail) !== false) {
$arrUsages[] = ' email "<a href="'.MANAGEURL.'?m=admin&sm=clients&edit='.$arrRow['s_users_id'].'">'.$arrRow['name'].'</a>"';
}
if (strpos($arrRow['site_user_settings_contact_email'], $strClientEmail) !== false) {
$arrUsages[] = ' email "<a href="'.MANAGEURL.'?m=admin&sm=clients&edit='.$arrRow['s_users_id'].'">'.$arrRow['name'].'</a>"';
}
}
$intUsagesCnt = count($arrUsages);
if ($intUsagesCnt > 0){
$strMessage = ' <span style="color: #000099;">'.$strClientEmail.'</span><br/>
';
if ($intUsagesCnt == 1){
$strMessage .= ' '.$arrUsages[0].'<br/>';
}else{
$strMessage .= ':<ul>';
foreach ($arrUsages as $strUsage){
$strMessage .= '<li>'.$strUsage.'</li>';
}
$strMessage .= '</ul>';
}
$strMessage .= '<br/>, .<br/><br/>
, ';
if (empty($objMailSender)) $objMailSender = new mailSender();
$objMailSender->sendMail('b@domain.com',' email ',$strMessage);
}
}
}
if (count($arrErrors)){
$strTo = 'my_email@domain.com';
$strSubj = ' ';
$strMessage = ' :'.
'<ul><li>'.implode('</li><li>',$arrErrors).'</li></ul>'.
'<br/>URL: '.filter_input(INPUT_SERVER, 'REQUEST_URI', FILTER_SANITIZE_URL);
if (empty($objMailSender)) $objMailSender = new mailSender();
$objMailSender->sendMail($strTo,$strSubj,$strMessage);
}
This script, like the first one, connects to the specified mailbox, selects the necessary letters from it (reports on undelivered messages) without a flag, finds in the letter the email address on which the letter was attempted to be sent and marks this letter with the "Processed" flag ... Then, manipulations are performed with the found e-mail address, as a result of which a human-readable letter is formed to the responsible employee.
The sources are available on GitHub .
That's all I wanted to tell in this article. Thanks for reading! If my code stung in your eyes, just roll up the spoiler or write your comments - I will be glad for constructive criticism.