gmail_api.py

# Copyright 2018 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Compiled from examples and modified by Mikko Mattila

import pickle
import base64
import os
from googleapiclient.discovery import build
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from apiclient import errors

# If modifying these scopes, delete the file token.pickle.
SCOPES = ['https://www.googleapis.com/auth/gmail.modify']

def GetService(creds_file):
    """Authorize with credentials in creds_file"""
    creds = None
    # The file token.pickle stores the user's access and refresh tokens, and is
    # created automatically when the authorization flow completes for the first
    # time.
    print("Logging in to GMail")
    if os.path.exists('token.pickle'):
        with open('token.pickle', 'rb') as token:
            creds = pickle.load(token)
    # If there are no (valid) credentials available, let the user log in.
    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(
                creds_file, SCOPES)
            creds = flow.run_local_server()
        # Save the credentials for the next run
        with open('token.pickle', 'wb') as token:
            pickle.dump(creds, token)
    service = build('gmail', 'v1', credentials=creds)
    print("Logged in!")
    return service

def ListMessagesMatchingQuery(service, user_id, query=''):
    """List all Messages of the user's mailbox matching the query.

    Args:
      service: Authorized Gmail API service instance.
      user_id: User's email address. The special value "me"
      can be used to indicate the authenticated user.
      query: String used to filter messages returned.
      Eg.- 'from:user@some_domain.com' for Messages from a particular sender.

    Returns:
      List of Messages that match the criteria of the query. Note that the
      returned list contains Message IDs, you must use get with the
      appropriate ID to get the details of a Message.
    """
    try:
        response = service.users().messages().list(userId=user_id, q=query).execute()
        messages = []
        if 'messages' in response:
            messages.extend(response['messages'])

        while 'nextPageToken' in response:
            page_token = response['nextPageToken']
            response = service.users().messages().list(userId=user_id, q=query,
                                                       pageToken=page_token).execute()
            messages.extend(response['messages'])

        return messages
    except errors.HttpError as error:
        print('An error occurred: %s' % error)
            
def GetAttachments(service, user_id, msg_id, store_dir):
    """Get and store attachment from Message with given id.

    Args:
        service: Authorized Gmail API service instance.
        user_id: User's email address. The special value "me"
                 can be used to indicate the authenticated user.
        msg_id: ID of Message containing attachment.
        store_dir: The directory used to store attachments.
    """
    attachments = []
    try:
        message = service.users().messages().get(userId=user_id, id=msg_id).execute()
    except errors.HttpError as error:
        print('An error occurred: %s' % error)
    
    for part in message['payload']['parts']:
        if part['filename']:
            att_id = part['body']['attachmentId']
            try:
                att_data = service.users().messages().attachments().get(id=att_id, messageId=msg_id, userId=user_id).execute()
            except errors.HttpError as error:
                print('An error occurred: %s' % error)
            file_data = base64.urlsafe_b64decode(att_data["data"].encode('UTF-8')).decode('UTF-8')
            path = os.path.join(store_dir, msg_id, part['filename'])
            attachments.append(path)
            if not os.path.exists(os.path.join(store_dir, msg_id)):
                os.makedirs(os.path.join(store_dir, msg_id))
            f = open(path, 'w')
            f.write(file_data)
            f.close()

    return attachments

def TrashMessage(service, user_id, msg_id):
    """Trash a Message.

    Args:
      service: Authorized Gmail API service instance.
      user_id: User's email address. The special value "me"
      can be used to indicate the authenticated user.
      msg_id: ID of Message to trash.
    """
    try:
        service.users().messages().trash(userId=user_id, id=msg_id).execute()
        print 'Message with id: %s trashed successfully.' % msg_id
    except errors.HttpError, error:
        print 'An error occurred: %s' % error