Beispiel #1
0
        /// <summary>
        /// Get all the messages in a folder
        /// </summary>
        /// <param name="folderId"></param>
        /// <param name="dataFormat"></param>
        /// <returns></returns>
        public async Task <GetUpdateResult <YouMailMessage[]> > GetMessagesAsync(int folderId, int imageSize, DataFormat dataFormat, int maxMessages = int.MaxValue)
        {
            try
            {
                AddPendingOp();
                GetUpdateResult <YouMailMessage[]> returnValue = null;
                if (await LoginWaitAsync())
                {
                    TraceLog(TraceLevelPriority.Normal, "Getting messages for folder: {0}", folderId);
                    var query = new YouMailMessageQuery(QueryType.GetMessages)
                    {
                        FolderId           = folderId,
                        DataFormat         = dataFormat,
                        MaxResults         = maxMessages,
                        Offset             = 0,
                        IncludePreview     = true,
                        IncludeContactInfo = true,
                        IncludeImageUrl    = true,
                        ImageSize          = imageSize,
                        PageLength         = s_PageLength,
                        Page = 1
                    };

                    returnValue = await ExecuteMessageQueryAsync(query);
                }
                return(returnValue);
            }
            finally
            {
                RemovePendingOp();
            }
        }
Beispiel #2
0
        /// <summary>
        /// Get the list of messages
        /// </summary>
        /// <param name="lastUpdated"></param>
        /// <param name="callback"></param>
        /// <param name="asyncState"></param>
        /// <returns></returns>
        public async Task <GetUpdateResult <YouMailHistory[]> > GetMessageHistoryAsync(DateTime lastUpdated, int imageSize)
        {
            GetUpdateResult <YouMailHistory[]> returnValue = null;

            try
            {
                AddPendingOp();
                if (await LoginWaitAsync())
                {
                    var query = new YouMailMessageQuery(QueryType.GetHistory)
                    {
                        MaxResults         = int.MaxValue,
                        Offset             = 0,
                        IncludeImageUrl    = true,
                        UpdatedFrom        = lastUpdated,
                        IncludeContactInfo = true,
                        ImageSize          = imageSize,
                        Page       = 1,
                        PageLength = s_PageLength
                    };

                    returnValue = await GetMessageHistoryFromQueryAsync(query);
                }
            }
            finally
            {
                RemovePendingOp();
            }

            return(returnValue);
        }
Beispiel #3
0
        /// <summary>
        /// Get the contacts for the user
        /// </summary>
        /// <param name="lastUpdated"></param>
        /// <returns></returns>
        public async Task <GetUpdateResult <YouMailContact[]> > GetContactsAsync(DateTime lastUpdated, int imageSize, YouMailContactType contactType = YouMailContactType.NoRestriction)
        {
            GetUpdateResult <YouMailContact[]> returnValue = null;

            try
            {
                AddPendingOp();
                if (await LoginWaitAsync())
                {
                    YouMailContactQuery query = new YouMailContactQuery(QueryType.GetContacts)
                    {
                        UpdatedFrom = lastUpdated,
                        ImageSize   = imageSize,
                        Page        = 1,
                        PageLength  = s_PageLength,
                        ContactType = contactType
                    };

                    returnValue = await ExecuteContactQueryAsync(query);
                }
            }
            finally
            {
                RemovePendingOp();
            }

            return(returnValue);
        }
Beispiel #4
0
        /// <summary>
        /// Get the list of greetings for the user
        /// </summary>
        /// <returns></returns>
        public async Task <GetUpdateResult <YouMailGreeting[]> > GetGreetingsAsync(DateTime lastUpdated)
        {
            GetUpdateResult <YouMailGreeting[]> returnValue = null;

            try
            {
                AddPendingOp();
                if (await LoginWaitAsync())
                {
                    YouMailGreetingQuery query = new YouMailGreetingQuery(QueryType.GetGreetings)
                    {
                        UpdatedFrom = lastUpdated,
                        Page        = 1,
                        PageLength  = s_PageLength
                    };

                    HttpResponseMessage    response  = null;
                    List <YouMailGreeting> greetings = new List <YouMailGreeting>();
                    DateTime lastQueryUpdated        = DateTime.MinValue;
                    int      count = 0;
                    do
                    {
                        count = 0;
                        using (response = await YouMailApiAsync(YMST.c_getGreetings + query.GetQueryString(), null, HttpMethod.Get))
                        {
                            var greetingResponse = DeserializeObject <YouMailGreetingsResponse>(response.GetResponseStream());
                            if (greetingResponse != null)
                            {
                                count = greetingResponse.Greetings.Length;
                                if (count > 0)
                                {
                                    greetings.AddRange(greetingResponse.Greetings);
                                }
                            }

                            if (lastQueryUpdated == DateTime.MinValue)
                            {
                                var date = response.Headers.Date.ToString();
                                lastQueryUpdated = DateTime.Parse(date);
                            }
                        }
                        query.Page++;
                    } while (count == query.PageLength);

                    returnValue = new GetUpdateResult <YouMailGreeting[]>(lastQueryUpdated, greetings.ToArray());
                }
            }
            finally
            {
                RemovePendingOp();
            }

            return(returnValue);
        }
Beispiel #5
0
 public async Task <GetUpdateResult <YouMailMessage[]> > GetMessagesFromQueryAsync(YouMailMessageQuery query)
 {
     try
     {
         AddPendingOp();
         GetUpdateResult <YouMailMessage[]> returnValue = null;
         if (await LoginWaitAsync())
         {
             returnValue = await ExecuteMessageQueryAsync(query);
         }
         return(returnValue);
     }
     finally
     {
         RemovePendingOp();
     }
 }
Beispiel #6
0
        /// <summary>
        /// Get a message history based on a YouMailQuery
        /// </summary>
        /// <param name="query"></param>
        /// <returns></returns>
        public async Task <GetUpdateResult <YouMailHistory[]> > GetMessageHistoryFromQueryAsync(YouMailQuery query)
        {
            GetUpdateResult <YouMailHistory[]> returnValue = null;
            HttpResponseMessage   response = null;
            List <YouMailHistory> callList = new List <YouMailHistory>();
            DateTime lastQueryUpdated      = DateTime.MinValue;
            int      count = 0;

            do
            {
                count = 0;
                string queryString = query.GetQueryString();

                using (response = await YouMailApiAsync(YMST.c_messageBoxHistoryQuery + queryString, null, HttpMethod.Get))
                {
                    var histories = DeserializeObject <YouMailHistories>(response.GetResponseStream());

                    // Get all the call histories where the result is no message left
                    if (histories != null && histories.Histories != null)
                    {
                        var messageQuery = from c in histories.Histories
                                           where c.Result != VoicemailResult.LeftMessage
                                           select c;

                        count = messageQuery.Count();
                        callList.AddRange(messageQuery);
                    }
                    if (lastQueryUpdated == DateTime.MinValue)
                    {
                        var date = response.Headers.Date.ToString();
                        lastQueryUpdated = DateTime.Parse(date);
                    }
                }
                query.Page++;
            } while (count == query.PageLength);

            returnValue = new GetUpdateResult <YouMailHistory[]>(lastQueryUpdated, callList.ToArray());
            return(returnValue);
        }