from imaplib import IMAP4_SSL
from email import message_from_string
from datetime import datetime, timedelta
import re
 
M = IMAP4_SSL ('imapserver')
M.login ('user', 'pass')
M.select ()
 
since = (datetime.today () - timedelta (days=5)).strftime ("%d-%b-%Y")
 
for user in users:
    typ, data = M.search (None, '(HEADER FROM "%s" SINCE %s)' % (user, since))
 
    for id in data[0].split ():
        typ, data = M.fetch (id, 'RFC822')
        msg = message_from_string (data[0][1])
        if not msg.is_multipart ():
            continue
 
        for part in msg.walk ():
            fn  = part.get_filename ()
            ext = re.match (r'.*\.(pptx?)$', fn):
            if not ext
                continue
 
            fp = file ('%s.%s.temp' % (user, ext.group (1)), 'w')
            fp.write (part.get_payload ())
            fp.close ()
 
M.close ()

raw      = part.get_payload ()
raw      = re.sub (r'[\r\n]+', '', raw)
encoding = part['Content-Transfer-Encoding'].lower ()
if encoding == 'base64':
    raw = b64decode (raw)
elif encoding == 'quoted-printable':
    raw = quopri.decodestring (raw)
else:
    print "ERROR: Unknown coding strategy - ignoring."
    continue

pythoncom.CoInitializeEx (pythoncom.COINIT_APARTMENTTHREADED)
gencache.EnsureModule ('{2DF8D04C-5BFA-101B-BDE5-00AA0044DE52}', 0, 2, 4)
gencache.EnsureDispatch ("PowerPoint.Application.12")
 
# Create an instance of PowerPoint and presentation
pp = Dispatch ("PowerPoint.Application.12")
pp.Activate ()
pres = pp.Presentations.Add ()
 
# Insert all the downloaded presentations
count = 1
for filename in os.listdir ('presentations'):
    pres.Slides.InsertFromFile (os.path.realpath (filename), count)
    count = pres.Slides.Count
 
# Save and exit
pres.SaveAs ('compiled.pptx')
pres.Close ()
pp.Quit ()
pythoncom.CoUninitialize ()

for filename in [f for f in os.listdir ('presentations') if f[-4:] == 'pptx']:
    pres = pp.Presentations.Open (path.realpath (filename))
    pres.SaveAs (path.realpath (filename[:-1]))
    pres.Close ()

fonts = {}
for i in range (1, pres.Fonts.Count + 1):
    fonts[pres.Fonts.Item (i).Name] = 1
fonts = fonts.keys ()
fonts.remove (u'Arial')
for font in fonts:
    pres.Fonts.Replace (font, u'Arial')

static size_t _CurlWriteCB (void* ptr, size_t nLen, size_t cbElem,
                            CMemFile* pFile)
{
    size_t cbSizeAtStart;
    size_t cbSizeAtEnd;
 
    // Write data to file, but measure buffer size before and after.
    cbSizeAtStart = (size_t)pFile->GetLength ();
    pFile->Write (ptr, (UINT)(nLen * cbElem));
    cbSizeAtEnd   = (size_t)pFile->GetLength ();
 
    // Return the difference in buffer size, i.e. number of bytes written.
    return (cbSizeAtEnd - cbSizeAtStart);
}
 
BYTE* GetStatusesFromTwitter (char* szUserName, UINT& uiSize)
{
    // Attempt to initialise curl
    CURL* curl = curl_easy_init ();
    if (curl != NULL) {
        // Set up the http target
        CString strFmt;
        strFmt.Format (IDS_TWITTER_STATUS, szUserName);
        curl_easy_setopt (curl, CURLOPT_URL, strFmt.GetString ());
 
        // Save the result into memory for now.
        CMemFile buffer;
        curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, _CurlWriteCB);
        curl_easy_setopt (curl, CURLOPT_WRITEDATA,     &buffer);
 
        // Attempt to grab the data from Twitter.
        CURLcode res = curl_easy_perform (curl);
        curl_easy_cleanup (curl);
 
        // Return the data.
        if (res == 0) {
            uiSize = (UINT)buffer.GetLength ();
            return buffer.Detach ();
        }
    }
 
    return NULL;
}

bool DoGetStatuses (char* szUserName)
{
    // Query Twitter
    UINT  uiSize;
    BYTE* pbData = GetStatusesFromTwitter (szUserName, uiSize)
    if (pbData == NULL)
        return false;
 
    // Move the memory into an object Xerces understands.
    MemBufInputSource* pDataSrc = new MemBufInputSource
        (pbData, uiSize, L"TwitterXML", true);
 
    // Parse the data
    XercesDOMParser parser;
    parser.setValidationScheme (XercesDOMParser::Val_Never);
    parser.setDoNamespaces (false);
    parser.setDoSchema (false);
    parser.setDoValidation (false);
    parser.parse (*(InputSource*)pDataSrc);
 
    // Get the root node
    DOMDocument* pDoc = parser.getDocument ();
 
    //...
 
    // Free memory.
    delete pDataSrc;
    return true;
}

int CPostStatusDlg::DoStatusUpdate ()
{
    static const char* cszUrl =
        "http://api.twitter.com/1/statuses/update.xml";
 
    // Attempt to initialise cURL.
    CURL* curl = curl_easy_init ();
    if (curl == NULL)
        return 0;
 
    // Configure the authentication
    CString strFmt;
    strFmt.Format (_T("%s:%s"), m_strUserName, m_strPassword);
    curl_easy_setopt (curl, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
    curl_easy_setopt (curl, CURLOPT_USERPWD,  (char*)strFmt.GetString ());
 
    // Format the string entire in C form.
    char* szStatus = curl_easy_escape (curl, m_strStatus.GetString (),
        m_strStatus.GetLength ());
    char szPostBody[BUFSIZ];
    sprintf (szPostBody, "status=%s", szStatus);
    curl_free (szStatus);
 
    // Set up the HTTP connection and use the POST method
    curl_easy_setopt (curl, CURLOPT_POST,           1L);
    curl_easy_setopt (curl, CURLOPT_POSTFIELDSIZE,  strlen (szPostBody));
    curl_easy_setopt (curl, CURLOPT_POSTFIELDS,     szPostBody);
 
    // Finally, set the callback function and the URL.
    CMemFile buffer;
    curl_easy_setopt (curl, CURLOPT_WRITEFUNCTION, _CurlWriteCB);
    curl_easy_setopt (curl, CURLOPT_WRITEDATA,     &buffer);
    curl_easy_setopt (curl, CURLOPT_URL,           cszUrl);
 
    // Now we can execute at last!
    int nResponse = 0;
    CURLcode res = curl_easy_perform (curl);
    curl_easy_getinfo (curl, CURLINFO_RESPONSE_CODE, &nResponse);
    curl_easy_cleanup (curl);
 
    // Check for success
    return nResponse;
}