mail.cxx

来自「pwlib源码库」· CXX 代码 · 共 918 行 · 第 1/2 页

#endif


BOOL PMail::GetMessageHeader(const PString & id,
                             Header & hdrInfo)
{
#if P_HAS_CMC
  if (cmc.IsLoaded()) {
    CMC_flags flags =  hUserInterface != NULL ? CMC_ERROR_UI_ALLOWED : 0;
    CMC_uint32 count = 1;
    CMC_message_summary * message;
    CMC_message_reference_ptr seed = id;

    lastError = cmc.list(sessionId,
                    NULL, flags, seed, &count, hUserInterface, &message, NULL);
    if (lastError != CMC_SUCCESS)
      return FALSE;

    hdrInfo.subject = message->subject;
    hdrInfo.received = PTime(0, message->time_sent.minute,
                                message->time_sent.hour,
                                message->time_sent.day,
                                message->time_sent.month,
                                message->time_sent.year);
    hdrInfo.originatorName = message->originator->name;
    if (message->originator->address != 0)
      hdrInfo.originatorAddress = message->originator->address;
    else
      hdrInfo.originatorAddress = '"' + hdrInfo.originatorName + '"';

    cmc.free_buf(message);
    return TRUE;
  }
#endif

#if P_HAS_MAPI
  if (mapi.IsLoaded()) {
    MapiMessage * message;
    lastError = mapi.ReadMail(sessionId,
                    (HWND)hUserInterface, id, MAPI_ENVELOPE_ONLY, 0, &message);
    if (lastError != SUCCESS_SUCCESS)
      return FALSE;

    PStringStream str = message->lpszDateReceived;
    int min, hr, day, mon, yr;
    char c;
    str >> yr >> c >> mon >> c >> day >> hr >> c >> min;

    hdrInfo.subject = message->lpszSubject;
    hdrInfo.received = PTime(0, min, hr, day, mon, yr);
    hdrInfo.originatorName = message->lpOriginator->lpszName;
    if (message->lpOriginator->lpszAddress != 0)
      hdrInfo.originatorAddress = message->lpOriginator->lpszAddress;
    else
      hdrInfo.originatorAddress = '"' + hdrInfo.originatorName + '"';

    mapi.FreeBuffer(message);
    return TRUE;
  }
#endif

  lastError = 1;
  return FALSE;
}


BOOL PMail::GetMessageBody(const PString & id, PString & body, BOOL markAsRead)
{
  body = PString();

#if P_HAS_CMC
  if (cmc.IsLoaded()) {
    CMC_flags flags = CMC_MSG_AND_ATT_HDRS_ONLY;
    if (!markAsRead)
      flags |= CMC_DO_NOT_MARK_AS_READ;
    if (hUserInterface != NULL)
      flags |= CMC_ERROR_UI_ALLOWED;

    CMC_message_reference_ptr seed = id;
    CMC_message * message;

    lastError = cmc.read(sessionId,seed,flags,&message,hUserInterface,NULL);
    if (lastError != CMC_SUCCESS)
      return FALSE;

    if (message->text_note != NULL)
      body = message->text_note;

    BOOL ok = (message->message_flags&CMC_MSG_TEXT_NOTE_AS_FILE) == 0;
    cmc.free_buf(message);

    return ok;
  }
#endif

#if P_HAS_MAPI
  if (mapi.IsLoaded()) {
    FLAGS flags = MAPI_SUPPRESS_ATTACH;
    if (!markAsRead)
      flags |= MAPI_PEEK;

    MapiMessage * message;

    lastError = mapi.ReadMail(sessionId,
                                 (HWND)hUserInterface, id, flags, 0, &message);
    if (lastError != SUCCESS_SUCCESS)
      return FALSE;

    body = message->lpszNoteText;
    mapi.FreeBuffer(message);
    return TRUE;
  }
#endif

  lastError = 1;
  return FALSE;
}


BOOL PMail::GetMessageAttachments(const PString & id,
                                  PStringArray & filenames,
                                  BOOL includeBody,
                                  BOOL markAsRead)
{
  filenames.SetSize(0);

#if P_HAS_CMC
  if (cmc.IsLoaded()) {
    CMC_flags flags = 0;
    if (!markAsRead)
      flags |= CMC_DO_NOT_MARK_AS_READ;
    if (hUserInterface != NULL)
      flags |= CMC_ERROR_UI_ALLOWED;

    CMC_message_reference_ptr seed = id;
    CMC_message * message;

    lastError = cmc.read(sessionId,seed,flags,&message,hUserInterface,NULL);
    if (lastError != CMC_SUCCESS)
      return FALSE;

    if (message->attachments != NULL) {
      PINDEX total = 1;
      for (CMC_attachment * attachment = message->attachments;
            (attachment->attach_flags&CMC_ATT_LAST_ELEMENT) != 0; attachment++)
        total++;
      filenames.SetSize(total);

      PINDEX attnum = 0;
      attachment = &message->attachments[attnum];
      do {
        if (includeBody ||
                       (message->message_flags&CMC_MSG_TEXT_NOTE_AS_FILE) == 0)
          filenames[attnum++] = attachment->attach_filename;
      } while (((attachment++)->attach_flags&CMC_ATT_LAST_ELEMENT) != 0);
    }

    cmc.free_buf(message);
    return TRUE;
  }
#endif

#if P_HAS_MAPI
  if (mapi.IsLoaded()) {
    FLAGS flags = 0;
    if (includeBody)
      flags |= MAPI_BODY_AS_FILE;
    if (!markAsRead)
      flags |= MAPI_PEEK;

    MapiMessage * message;
    lastError = mapi.ReadMail(sessionId,
                                 (HWND)hUserInterface, id, flags, 0, &message);
    if (lastError != SUCCESS_SUCCESS)
      return FALSE;

    filenames.SetSize(message->nFileCount);
    for (PINDEX i = 0; i < filenames.GetSize(); i++)
      filenames[i] = message->lpFiles[i].lpszPathName;

    mapi.FreeBuffer(message);
    return TRUE;
  }
#endif

  lastError = 1;
  return FALSE;
}


BOOL PMail::MarkMessageRead(const PString & id)
{
#if P_HAS_CMC
  if (cmc.IsLoaded()) {
    CMC_flags flags = CMC_MSG_AND_ATT_HDRS_ONLY;
    if (hUserInterface != NULL)
      flags |= CMC_ERROR_UI_ALLOWED;

    CMC_message_reference_ptr seed = id;
    CMC_message * message;

    lastError = cmc.read(sessionId,seed,flags,&message,hUserInterface,NULL);
    if (lastError != CMC_SUCCESS)
      return FALSE;

    cmc.free_buf(message);
    return TRUE;
  }
#endif

#if P_HAS_MAPI
  if (mapi.IsLoaded()) {
    MapiMessage * message;
    lastError = mapi.ReadMail(sessionId,
                    (HWND)hUserInterface, id, MAPI_ENVELOPE_ONLY, 0, &message);
    if (lastError != SUCCESS_SUCCESS)
      return FALSE;

    mapi.FreeBuffer(message);
    return TRUE;
  }
#endif

  lastError = 1;
  return FALSE;
}


BOOL PMail::DeleteMessage(const PString & id)
{
#if P_HAS_CMC
  if (cmc.IsLoaded()) {
    CMC_flags flags =  hUserInterface != NULL ? CMC_ERROR_UI_ALLOWED : 0;
    CMC_message_reference_ptr seed = id;

    lastError = cmc.act_on(sessionId,
                         seed, CMC_ACT_ON_DELETE, flags, hUserInterface, NULL);
    return lastError == CMC_SUCCESS;
  }
#endif

#if P_HAS_MAPI
  if (mapi.IsLoaded()) {
    lastError = mapi.DeleteMail(sessionId, (HWND)hUserInterface, id, 0, 0);
    return lastError == SUCCESS_SUCCESS;
  }
#endif

  lastError = 1;
  return FALSE;
}


PMail::LookUpResult PMail::LookUp(const PString & name, PString * fullName)
{
#if P_HAS_CMC
  if (cmc.IsLoaded()) {
    CMC_recipient recip_in;
    memset(&recip_in, 0, sizeof(recip_in));
    recip_in.name = (CMC_string)(const char *)name;
    recip_in.recip_flags = CMC_RECIP_LAST_ELEMENT;

    CMC_recipient * recip_out;
    CMC_uint32 count = 1;
    lastError = cmc.look_up(sessionId, &recip_in, CMC_LOOKUP_RESOLVE_IDENTITY,
                          (CMC_ui_id)hUserInterface, &count, &recip_out, NULL);
    switch (lastError) {
      case CMC_SUCCESS :
        if (fullName != NULL)
          *fullName = recip_out->name;
        cmc.free_buf(recip_out);
        return ValidUser;

      case CMC_E_AMBIGUOUS_RECIPIENT :
        return AmbiguousUser;

      case CMC_E_RECIPIENT_NOT_FOUND :
        return UnknownUser;
    }
  
    return LookUpError;
  }
#endif

#if P_HAS_MAPI
  if (mapi.IsLoaded()) {
    MapiRecipDesc * recip;
    lastError = mapi.ResolveName(sessionId,
                      (HWND)hUserInterface, name, MAPI_AB_NOMODIFY, 0, &recip);

    switch (lastError) {
      case SUCCESS_SUCCESS :
        if (fullName != NULL)
          *fullName = recip->lpszName;
        mapi.FreeBuffer(recip);
        return ValidUser;

      case MAPI_E_AMBIGUOUS_RECIPIENT :
        return AmbiguousUser;

      case MAPI_E_UNKNOWN_RECIPIENT :
        return UnknownUser;
    }
  
    return LookUpError;
  }
#endif

  lastError = 1;
  return LookUpError;
}


int PMail::GetErrorCode() const
{
  return (int)lastError;
}


PString PMail::GetErrorText() const
{
#if P_HAS_CMC
  static const char * const cmcErrMsg[] = {
    "CMC_SUCCESS",
    "CMC_E_AMBIGUOUS_RECIPIENT",
    "CMC_E_ATTACHMENT_NOT_FOUND",
    "CMC_E_ATTACHMENT_OPEN_FAILURE",
    "CMC_E_ATTACHMENT_READ_FAILURE",
    "CMC_E_ATTACHMENT_WRITE_FAILURE",
    "CMC_E_COUNTED_STRING_UNSUPPORTED",
    "CMC_E_DISK_FULL",
    "CMC_E_FAILURE",
    "CMC_E_INSUFFICIENT_MEMORY",
    "CMC_E_INVALID_CONFIGURATION",
    "CMC_E_INVALID_ENUM",
    "CMC_E_INVALID_FLAG",
    "CMC_E_INVALID_MEMORY",
    "CMC_E_INVALID_MESSAGE_PARAMETER",
    "CMC_E_INVALID_MESSAGE_REFERENCE",
    "CMC_E_INVALID_PARAMETER",
    "CMC_E_INVALID_SESSION_ID",
    "CMC_E_INVALID_UI_ID",
    "CMC_E_LOGON_FAILURE",
    "CMC_E_MESSAGE_IN_USE",
    "CMC_E_NOT_SUPPORTED",
    "CMC_E_PASSWORD_REQUIRED",
    "CMC_E_RECIPIENT_NOT_FOUND",
    "CMC_E_SERVICE_UNAVAILABLE",
    "CMC_E_TEXT_TOO_LARGE",
    "CMC_E_TOO_MANY_FILES",
    "CMC_E_TOO_MANY_RECIPIENTS",
    "CMC_E_UNABLE_TO_NOT_MARK_AS_READ",
    "CMC_E_UNRECOGNIZED_MESSAGE_TYPE",
    "CMC_E_UNSUPPORTED_ACTION",
    "CMC_E_UNSUPPORTED_CHARACTER_SET",
    "CMC_E_UNSUPPORTED_DATA_EXT",
    "CMC_E_UNSUPPORTED_FLAG",
    "CMC_E_UNSUPPORTED_FUNCTION_EXT",
    "CMC_E_UNSUPPORTED_VERSION",
    "CMC_E_USER_CANCEL",
    "CMC_E_USER_NOT_LOGGED_ON"
  };
  if (cmc.IsLoaded()) {
    if (lastError < PARRAYSIZE(cmcErrMsg))
      return cmcErrMsg[lastError];
    return PString(PString::Printf, "CMC Error=%lu", lastError);
  }
#endif

#if P_HAS_MAPI
  static const char * const mapiErrMsg[] = {
    "SUCCESS_SUCCESS",
    "MAPI_USER_ABORT",
    "MAPI_E_FAILURE",
    "MAPI_E_LOGIN_FAILURE",
    "MAPI_E_DISK_FULL",
    "MAPI_E_INSUFFICIENT_MEMORY",
    "MAPI_E_ACCESS_DENIED",
    "MAPI_E_UNKNOWN",
    "MAPI_E_TOO_MANY_SESSIONS",
    "MAPI_E_TOO_MANY_FILES",
    "MAPI_E_TOO_MANY_RECIPIENTS",
    "MAPI_E_ATTACHMENT_NOT_FOUND",
    "MAPI_E_ATTACHMENT_OPEN_FAILURE",
    "MAPI_E_ATTACHMENT_WRITE_FAILURE",
    "MAPI_E_UNKNOWN_RECIPIENT",
    "MAPI_E_BAD_RECIPTYPE",
    "MAPI_E_NO_MESSAGES",
    "MAPI_E_INVALID_MESSAGE",
    "MAPI_E_TEXT_TOO_LARGE",
    "MAPI_E_INVALID_SESSION",
    "MAPI_E_TYPE_NOT_SUPPORTED",
    "MAPI_E_AMBIGUOUS_RECIPIENT",
    "MAPI_E_MESSAGE_IN_USE",
    "MAPI_E_NETWORK_FAILURE",
    "MAPI_E_INVALID_EDITFIELDS",
    "MAPI_E_INVALID_RECIPS",
    "MAPI_E_NOT_SUPPORTED"
  };
  if (mapi.IsLoaded()) {
    if (lastError < PARRAYSIZE(mapiErrMsg))
      return mapiErrMsg[lastError];
    return PString(PString::Printf, "MAPI Error=%lu", lastError);
  }
#endif

  return "No mail library loaded.";
}


#if P_HAS_CMC
PMail::CMCDLL::CMCDLL()
#ifdef _WIN32
  : PDynaLink("MAPI32.DLL")
#else
  : PDynaLink("CMC.DLL")
#endif
{
  if (!GetFunction("cmc_logon", (Function &)logon) ||
      !GetFunction("cmc_logoff", (Function &)logoff) ||
      !GetFunction("cmc_free", (Function &)free_buf) ||
      !GetFunction("cmc_query_configuration", (Function &)query_configuration) ||
      !GetFunction("cmc_look_up", (Function &)look_up) ||
      !GetFunction("cmc_list", (Function &)list) ||
      !GetFunction("cmc_send", (Function &)send) ||
      !GetFunction("cmc_read", (Function &)read) ||
      !GetFunction("cmc_act_on", (Function &)act_on))
    Close();
}
#endif


#if P_HAS_MAPI
PMail::MAPIDLL::MAPIDLL()
#ifdef _WIN32
  : PDynaLink("MAPI32.DLL")
#else
  : PDynaLink("MAPI.DLL")
#endif
{
  if (!GetFunction("MAPILogon", (Function &)Logon) ||
      !GetFunction("MAPILogoff", (Function &)Logoff) ||
      !GetFunction("MAPISendMail", (Function &)SendMail) ||
      !GetFunction("MAPISendDocuments", (Function &)SendDocuments) ||
      !GetFunction("MAPIFindNext", (Function &)FindNext) ||
      !GetFunction("MAPIReadMail", (Function &)ReadMail) ||
      !GetFunction("MAPISaveMail", (Function &)SaveMail) ||
      !GetFunction("MAPIDeleteMail", (Function &)DeleteMail) ||
      !GetFunction("MAPIFreeBuffer", (Function &)FreeBuffer) ||
      !GetFunction("MAPIAddress", (Function &)Address) ||
      !GetFunction("MAPIDetails", (Function &)Details) ||
      !GetFunction("MAPIResolveName", (Function &)ResolveName))
    Close();
}
#endif


// End Of File ///////////////////////////////////////////////////////////////