internal ImapCopiedUidSet(long uidValidity, ImapSequenceSet copiedUidSet, ImapSequenceSet assignedUidSet)
: base(true)
{
this.UidValidity = uidValidity;
this.CopiedUidSet = copiedUidSet;
this.AssignedUidSet = assignedUidSet;
}
public ImapMessageNotFoundException(string message, ImapSequenceSet sequenceOrUidSet)
: base(message)
{
if (sequenceOrUidSet == null)
throw new ArgumentNullException("sequenceOrUidSet");
this.sequenceOrUidSet = sequenceOrUidSet;
}
internal ImapWebClientFetchMessageBodyStream(ImapSession session,
bool keepAlive,
bool peek,
ImapSequenceSet fetchUidSet,
int fetchBlockSize,
int readWriteTimeout)
: this(session, keepAlive, peek, fetchUidSet, null, null, fetchBlockSize, readWriteTimeout)
{
}
private ImapWebResponse GetFetchResponse(ImapSequenceSet requestedUidSet)
{
var section = ImapStyleUriParser.GetSection(RequestUri);
var partial = ImapStyleUriParser.GetPartial(RequestUri);
if (string.IsNullOrEmpty(section) && partial == null)
return GetFullFetchResponse(requestedUidSet);
else
return GetPartialFetchResponse(requestedUidSet, section, partial);
}
public ImapMatchedSequenceSet(ImapSequenceSet sequenceSet)
: base(sequenceSet.IsUidSet)
{
this.SequenceSet = sequenceSet;
this.IsSavedResult = false;
this.Tag = null;
this.HighestModSeq = null;
this.Min = null;
this.Max = null;
this.Count = null;
}
internal ImapWebClientFetchMessageBodyStream(ImapSession session,
bool keepAlive,
bool peek,
ImapSequenceSet fetchUidSet,
string fetchSection,
ImapPartialRange? fetchRange,
int fetchBlockSize,
int readWriteTimeout)
: base(session, peek, fetchUidSet, fetchSection, fetchRange, fetchBlockSize)
{
this.keepAlive = keepAlive;
ReadTimeout = readWriteTimeout;
WriteTimeout = readWriteTimeout;
}
protected ImapWebResponse GetCopyResponse(ImapSequenceSet requestUidSet)
{
ImapCopiedUidSet copiedUids;
ImapMailbox createdMailbox = null;
var mailbox = GetDestinationMailbox();
var response = new ImapWebResponse(AllowCreateMailbox
? Session.Copy(requestUidSet, mailbox, out copiedUids, out createdMailbox)
: Session.Copy(requestUidSet, mailbox, out copiedUids));
if (response.Result.Succeeded) {
if (createdMailbox != null) {
if (Subscription) {
Session.Subscribe(createdMailbox);
Session.Lsub(createdMailbox);
}
else {
Session.List(createdMailbox);
}
response.Mailboxes = new[] {createdMailbox};
}
if (copiedUids != null) {
var builder = new ImapUriBuilder(DestinationUri);
builder.UidValidity = copiedUids.UidValidity;
if (copiedUids.AssignedUidSet.IsSingle)
builder.Uid = copiedUids.AssignedUidSet.ToNumber();
else
builder.SearchCriteria = ImapSearchCriteria.Uid(copiedUids.AssignedUidSet);
response.SetResponseUri(builder.Uri);
}
}
return response;
}
public static ImapSearchCriteria SequenceOrUidSet(ImapSequenceSet sequenceOrUidSet)
{
if (sequenceOrUidSet == null)
throw new ArgumentNullException("sequenceOrUidSet");
else if (sequenceOrUidSet.IsEmpty)
throw new ArgumentException("empty set", "sequenceOrUidSet");
if (sequenceOrUidSet.IsUidSet)
return new ImapSearchCriteria("UID", sequenceOrUidSet.ToString());
else
return new ImapSearchCriteria(sequenceOrUidSet.ToString());
}
public MessageSet(ImapOpenedMailboxInfo mailbox, ImapSequenceSet sequenceOrUidSet)
: base(mailbox)
{
this.sequenceOrUidSet = sequenceOrUidSet;
}
private void TestMessage(int existMessageCount, ImapCapability[] capabilities, ImapSequenceSet sequenceOrUidSet, Action<ImapPseudoServer, ImapMessageInfoBase, ImapMessageInfo[]> action)
{
TestUtils.TestAuthenticated(capabilities, delegate(ImapPseudoServer server, ImapClient client) {
// LIST
server.EnqueueTaggedResponse("* LIST () \".\" INBOX\r\n" +
"$tag OK done\r\n");
// SELECT
server.EnqueueTaggedResponse(string.Format("* EXISTS {0}\r\n", existMessageCount) +
"* OK [UIDVALIDITY 1]\r\n" +
"$tag OK done\r\n");
using (var inbox = client.OpenInbox()) {
server.DequeueRequest(); // LIST
server.DequeueRequest(); // SELECT
var messages = new ImapMessageInfo[0];
if (0 < existMessageCount) {
// NOOP
server.EnqueueTaggedResponse("$tag OK done\r\n");
// FETCH
var fetchResp = new StringBuilder();
for (var seq = 1; seq <= existMessageCount; seq++) {
fetchResp.AppendFormat("* FETCH {0} (UID {0})\r\n", seq);
}
fetchResp.Append("$tag OK done\r\n");
server.EnqueueTaggedResponse(fetchResp.ToString());
messages = inbox.GetMessages().ToArray();
server.DequeueRequest(); // NOOP
server.DequeueRequest(); // FETCH
}
try {
var messageSet = new MessageSet(inbox, sequenceOrUidSet);
Assert.AreSame(messageSet.Client, client);
Assert.AreSame(messageSet.Mailbox, inbox);
Assert.AreEqual(1L, messageSet.UidValidity);
action(server, messageSet, messages);
}
finally {
if (inbox.IsOpen)
// CLOSE
server.EnqueueTaggedResponse("$tag OK done\r\n");
}
}
});
}
private void TestMessage(int existMesasgeCount, ImapSequenceSet sequenceOrUidSet, Action<ImapPseudoServer, ImapMessageInfoBase, ImapMessageInfo[]> action)
{
TestMessage(existMesasgeCount, null, sequenceOrUidSet, action);
}
public ImapMatchedSequenceSet(ImapSequenceSet sequenceSet, ulong highestModSeq)
: this(sequenceSet)
{
this.HighestModSeq = highestModSeq;
}
protected ImapWebResponse GetStoreResponse(ImapSequenceSet requestUidSet)
{
if (StoreDataItem == null)
throw new InvalidOperationException("StoreDataItem must be set");
return new ImapWebResponse(Session.Store(requestUidSet, StoreDataItem));
}
private ImapWebResponse GetFullFetchResponse(ImapSequenceSet requestedUidSet)
{
var responseStream = new ImapWebClientFetchMessageBodyStream(Session,
KeepAlive,
FetchPeek,
requestedUidSet,
FetchBlockSize,
ReadWriteTimeout);
IImapMessageAttribute messageAttr;
var response = new ImapWebResponse(responseStream.Prepare(GetFetchDataItem(), out messageAttr));
if (response.Result.Failed)
return response;
response.MessageAttributes = new[] {messageAttr};
response.SetResponseStream(responseStream,
responseStream.Length,
true);
if (messageAttr.BodyStructure != null)
response.SetContentType((string)messageAttr.BodyStructure.MediaType);
return response;
}
private static bool IsSavedResult(ImapSequenceSet sequenceOrUidSet)
{
var matchedSet = sequenceOrUidSet as ImapMatchedSequenceSet;
if (matchedSet == null)
return false;
else
return matchedSet.IsSavedResult;
}
// <sequence set>
// Messages with message sequence numbers corresponding to the
// specified message sequence number set.
public static ImapSearchCriteria SequenceSet(ImapSequenceSet sequenceSet)
{
if (sequenceSet == null)
throw new ArgumentNullException("sequenceSet");
else if (sequenceSet.IsEmpty)
throw new ArgumentException("empty set", "sequenceSet");
else if (!IsSavedResult(sequenceSet) && sequenceSet.IsUidSet)
throw new ArgumentException("not sequence set", "sequenceSet");
return new ImapSearchCriteria(sequenceSet.ToString());
}
public ArrivalMessageQuery(WaitForMessageArrivalContext context)
{
sequenceSet = (!context.MessageArrived || context.Mailbox.ExistsMessage <= context.CurrentMessageCount)
? ImapSequenceSet.CreateSet(new long[0])
: ImapSequenceSet.CreateRangeSet(context.CurrentMessageCount + 1, context.Mailbox.ExistsMessage);
}
private ImapMessageInfo GetMessage(ImapSequenceSet sequenceOrUidSet, ImapMessageFetchAttributeOptions options)
{
var message = (new ImapMessageInfoList(this, options, sequenceOrUidSet)).FirstOrDefault();
if (message == null)
throw new ImapMessageNotFoundException(sequenceOrUidSet);
return message;
}
internal void CheckUidValidity(long uidValidity, ImapSequenceSet sequenceOrUidSet)
{
// TODO: impl
#if false
if (!sequenceOrUidSet.IsUidSet)
return;
if (uidValidity != UidValidity)
throw new ImapException("UIDVALIDITY value has been changed");
#endif
}
private void StoreCore(ImapSequenceSet sequenceOrUidSet, ImapStoreDataItem storeDataItem)
{
if (sequenceOrUidSet.IsEmpty)
return; // do nothing
Mailbox.CheckSelected();
Mailbox.CheckUidValidity(UidValidity, sequenceOrUidSet);
PrepareOperation();
Mailbox.ProcessResult(Client.Session.Store(sequenceOrUidSet, storeDataItem));
}
protected ImapWebResponse GetExpungeResponse(ImapSequenceSet requestUidSet)
{
var result = Session.Store(requestUidSet, ImapStoreDataItem.AddFlagsSilent(ImapMessageFlag.Deleted));
if (result.Failed)
return new ImapWebResponse(result);
if (Session.ServerCapabilities.Has(ImapCapability.UidPlus))
result = Session.UidExpunge(requestUidSet);
else
result = Session.Expunge();
return new ImapWebResponse(result);
}
// UID <sequence set>
// Messages with unique identifiers corresponding to the specified
// unique identifier set. Sequence set ranges are permitted.
public static ImapSearchCriteria Uid(ImapSequenceSet uidSet)
{
if (uidSet == null)
throw new ArgumentNullException("uidSet");
else if (uidSet.IsEmpty)
throw new ArgumentException("empty set", "uidSet");
else if (!IsSavedResult(uidSet) && !uidSet.IsUidSet)
throw new ArgumentException("not uid set", "uidSet");
return new ImapSearchCriteria("UID", uidSet.ToString());
}
public ImapMessageNotFoundException(ImapSequenceSet sequenceOrUidSet)
: this(string.Format("no such message: {0} ({1})", sequenceOrUidSet, sequenceOrUidSet.IsUidSet ? "uid" : "sequence"),
sequenceOrUidSet)
{
}
internal ImapAppendedUidSet(long uidValidity, ImapSequenceSet assignedUidSet)
: base(true)
{
this.UidValidity = uidValidity;
this.AssignedUidSet = assignedUidSet;
}
private ImapWebResponse GetPartialFetchResponse(ImapSequenceSet requestedUidSet, string section, ImapPartialRange? partial)
{
var responseStream = new ImapWebClientFetchMessageBodyStream(Session,
KeepAlive,
FetchPeek,
requestedUidSet,
section,
partial,
FetchBlockSize,
ReadWriteTimeout);
IImapMessageAttribute discard;
var response = new ImapWebResponse(responseStream.Prepare(GetFetchDataItem(), out discard));
if (response.Result.Failed)
return response;
response.SetResponseStream(responseStream,
responseStream.Length,
true);
return response;
}
