/// <summary>
        /// Modifies the <see cref="AtomEntry"/> to match the data source.
        /// </summary>
        /// <param name="resource">The <see cref="AtomEntry"/> to be filled.</param>
        /// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception>
        public void Fill(AtomEntry resource)
        {
            //------------------------------------------------------------
            //	Validate parameter
            //------------------------------------------------------------
            Guard.ArgumentNotNull(resource, "resource");

            //------------------------------------------------------------
            //	Create namespace resolver
            //------------------------------------------------------------
            XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(this.Navigator.NameTable);

            //------------------------------------------------------------
            //	Attempt to fill syndication resource
            //------------------------------------------------------------
            //BEGIN PATCH
            //Update from tracker #4797, but changed slightly from that patch.
            //Not all hosts are explicitly tagging the entry as "atom:entry".
            //XPathNavigator entryNavigator   = this.Navigator.SelectSingleNode("atom:entry", manager);
            XPathNavigator entryNavigator = this.Navigator.SelectSingleNode("//*[local-name()='entry']", manager);
            //END PATCH

            if (entryNavigator != null)
            {
                Atom10SyndicationResourceAdapter.FillEntry(resource, entryNavigator, manager, this.Settings);
            }
        }
 public void SingleResource_Verify_CanConstructWithTemplateEntry()
 {
     var entry = new AtomEntry();
     var request = new SDataSingleResourceRequest(_service, entry);
     Expect(request, Is.Not.Null);
     Expect(request.Entry, Is.Not.Null);
 }
        public void SingleResource_Verify_CanCreate()
        {
            var request = new SDataSingleResourceRequest(_service) {ResourceKind = "employees"};

            var payload = new SDataPayload();
            payload.Values["Title"] = "create 1";
            payload.Values["NationalIdNumber"] = "44444";
            payload.Values["LoginId"] = "create 4";
            payload.Values["ContactId"] = "9999";
            payload.Values["BirthDate"] = SyndicationDateTimeUtility.ToRfc3339DateTime(new DateTime(1970, 8, 2));
            payload.Values["HireDate"] = SyndicationDateTimeUtility.ToRfc3339DateTime(DateTime.Now);
            payload.Values["ModifiedDate"] = SyndicationDateTimeUtility.ToRfc3339DateTime(DateTime.Now);
            payload.Values["MaritalStatus"] = "Single";
            payload.Values["SalariedFlag"] = XmlConvert.ToString(true);
            payload.Values["CurrentFlag"] = XmlConvert.ToString(true);
            payload.Values["Gender"] = "Male";
            payload.Values["RowGuid"] = Guid.NewGuid().ToString();

            var entry = new AtomEntry
                        {
                            UpdatedOn = DateTime.Now,
                            PublishedOn = DateTime.Now
                        };
            entry.SetSDataPayload(payload);
            request.Entry = entry;
            _mock.Setup(s => s.CreateEntry(request, request.Entry)).Returns(TestData.Entry);

            entry = request.Create();
            Expect(entry, Is.Not.Null);
        }
        private void cmdSave_Click(object sender, EventArgs e)
        {
            try
            {
                ISDataService service;
                service = SDataDataService.mydataService();

                var entry = new AtomEntry();
                var payload = new SDataPayload
                {
                    ResourceName = "Lead",
                    Namespace = "http://schemas.sage.com/dynamic/2007",
                    Values = {
                        {"Company", txtCompany.Text.Trim()},
                        {"FirstName",txtFName.Text.Trim()},
                        {"LastName",txtLName.Text.Trim()},
                        {"Email",txtEmail.Text.Trim()},
                        {"Address",
                                new SDataPayload {
                                    ResourceName = "LeadAddress",
                                    Values = {
                                        {"Address1",  txtAddress.Text.Trim()},
                                        {"City", txtCity.Text.Trim()},
                                        {"State", txtState.Text.Trim()},
                                        {"PostalCode",txtPostalCode.Text.Trim()}
                                    }
                                }
                        }
                    }
                };

                entry.SetSDataPayload(payload);
                var request = new SDataSingleResourceRequest(service, entry) { ResourceKind = "leads" };
                AtomEntry result = request.Create();

                if (result != null)
                {
                    this.DialogResult = System.Windows.Forms.DialogResult.Yes;
                }

                this.Close();

            }
            catch (SDataClientException ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        private void cmdSave_Click(object sender, EventArgs e)
        {
            try
            {
                ISDataService service;
                service = SDataDataService.mydataService();

                var entry = new AtomEntry();
                var payload = new SDataPayload
                {
                    ResourceName = "Account",
                    Namespace = "http://schemas.sage.com/dynamic/2007",
                    Values = {
                        {"AccountName", txtAccount.Text},
                        {"Contacts", new SDataPayloadCollection {
                                new SDataPayload {
                                    ResourceName = "Contact",
                                    Values = {
                                        {"AccountName",  txtAccount.Text},
                                        {"LastName", txtLName.Text},
                                        {"FirstName", txtFName.Text},
                                        {"Email",txtEmail.Text}
                                    }
                                }
                            }
                        }
                    }
                };

                entry.SetSDataPayload(payload);
                var request = new SDataSingleResourceRequest(service, entry) { ResourceKind = "accounts" };
                AtomEntry result = request.Create();

                if(result != null)
                {
                    this.DialogResult = System.Windows.Forms.DialogResult.Yes;
                }

                this.Close();

            }
            catch (SDataClientException ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        private void cmdSave_Click(object sender, EventArgs e)
        {
            try
            {
                ISDataService service;
                service = SDataDataService.mydataService();

                string ownerId = UserNameToOwnerId.GetId(service.UserName);
                string userId = UserNameToId.GetId(service.UserName);

                var entry = new AtomEntry();
                var payload = new SDataPayload
                {
                    ResourceName = "Opportunity",
                    Namespace = "http://schemas.sage.com/dynamic/2007",
                    Values = {
                                {"Description", txtDescription.Text},
                                {"Account", (SDataPayload)contactPayload.Values["Account"]},
                                {"Owner", new SDataPayload{ Key = ownerId, ResourceName="Owner"}},
                                {"AccountManager", new SDataPayload{ Key = userId, ResourceName="AccountManager"}},
                                {"Contacts",
                                    new SDataPayloadCollection {
                                        new SDataPayload {
                                            ResourceName = "OpportunityContact",
                                            Values = {{"Contact",new SDataPayload{ Key = contactPayload.Key}},
                                                      {"IsPrimary","true"}}
                                        }
                                    }
                                }
                             }
                };

                entry.SetSDataPayload(payload);
                var request = new SDataSingleResourceRequest(service, entry) { ResourceKind = "Opportunities" };
                AtomEntry result = request.Create();

                this.Close();

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        private void cmdSave_Click(object sender, EventArgs e)
        {
            try
            {
                ISDataService service;
                service = SDataDataService.mydataService();

                string contactId = contactPayload.Key; ;
                string contactName = contactPayload.Values["FirstName"].ToString().Trim() + " " + contactPayload.Values["LastName"].ToString().Trim();

                SDataPayload accountPayload = (SDataPayload)contactPayload.Values["Account"];
                string accountId = accountPayload.Key;
                string accountName = contactPayload.Values["AccountName"].ToString().Trim();

                var entry = new AtomEntry();
                var payload = new SDataPayload
                {
                    ResourceName = "Activity",
                    Namespace = "http://schemas.sage.com/dynamic/2007",
                    Values = {
                    {"AccountId", accountId},
                    //{"AccountName", accountName},
                    {"ContactId", contactId},
                    {"Description", txtRegarding.Text}
                    }
                };

                entry.SetSDataPayload(payload);
                var request = new SDataSingleResourceRequest(service, entry) { ResourceKind = "Activities" };
                AtomEntry result = request.Create();

                if (result != null)
                {
                    //MessageBox.Show("Acctivity created");
                }

                this.Close();

            }
            catch (SDataClientException ex)
            {
                MessageBox.Show(ex.Message);
            }
        }
        private void cmdSave_Click(object sender, EventArgs e)
        {
            try
            {
                ISDataService service;
                service = SDataDataService.mydataService();

                string ownerId = UserNameToOwnerId.GetId(service.UserName);

                var entry = new AtomEntry();
                var payload = new SDataPayload
                {
                    ResourceName = "Ticket",
                    Namespace = "http://schemas.sage.com/dynamic/2007",
                    Values = {
                    {"Account", (SDataPayload)contactPayload.Values["Account"]},
                    {"Contact", contactPayload},//,
                                {"AssignedTo", new SDataPayload{ Key = ownerId, ResourceName="Owner"}},
                                //{"Issue",txtSubject.Text},
                                {"TicketProblem", new SDataPayload{
                                    ResourceName="TicketProblem",
                                    Values = {
                                        {"Notes",txtSubject.Text}
                                    }
                                }
                                }
                    }
                };

                entry.SetSDataPayload(payload);
                var request = new SDataSingleResourceRequest(service, entry) { ResourceKind = "Tickets" };
                AtomEntry result = request.Create();

                this.Close();

            }
            catch (SDataClientException ex)
            {
                //MessageBox.Show(ex.Message);
                //Getting object reference error and have no idea why
                //Everything is created just fine and is working though still get error
                this.Close();
            }
        }
        public void Typical_Entry()
        {
            var xml = @"<entry xmlns=""http://www.w3.org/2005/Atom""
                               xmlns:sync=""http://schemas.sage.com/sdata/sync/2008/1"">
                          <sync:syncState>
                            <sync:endpoint>http://www.example.com/sdata/myApp1/myContract/-/accounts</sync:endpoint>
                            <sync:tick>5</sync:tick>
                            <sync:stamp>2008-10-30T14:55:43Z</sync:stamp>
                          </sync:syncState>
                        </entry>";
            var entry = new AtomEntry();
            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
            {
                entry.Load(stream);
            }

            var syncState = entry.GetSDataSyncState();
            Assert.That(syncState.EndPoint, Is.EqualTo("http://www.example.com/sdata/myApp1/myContract/-/accounts"));
            Assert.That(syncState.Tick, Is.EqualTo(5L));
            Assert.That(syncState.Stamp, Is.EqualTo(new DateTime(2008, 10, 30, 14, 55, 43)));
        }
    public static string Create(string oppoId, string contactId)
    {
        try
            {
                ISDataService service;
                service = SDataDataService.mydataService();

                var entry = new AtomEntry();
                var payload = new SDataPayload
                {
                    ResourceName = "OpportunityContact",
                    Namespace = "http://schemas.sage.com/dynamic/2007",
                    Values = {
                                {"Contact", new SDataPayload{ Key = contactId, ResourceName="Contact"}},
                                {"Opportunity", new SDataPayload{ Key = oppoId, ResourceName="Opportunity"}}
                             }
                };

                entry.SetSDataPayload(payload);
                var request = new SDataSingleResourceRequest(service, entry) { ResourceKind = "OpportunityContacts" };
                AtomEntry result = request.Create();

                if (result != null)
                {
                    return result.Id.ToString();
                }
                else
                {
                    return null;
                }
            }
            catch (Exception ex)
            {
                return null;
            }
    }
        /// <summary>
        /// Modifies the <see cref="AtomEntry"/> to match the supplied <see cref="XPathNavigator"/> data source.
        /// </summary>
        /// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
        /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
        /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
        /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
        /// <remarks>
        ///     This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomEntry"/>.
        /// </remarks>
        /// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
        private static void FillEntry(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
        {
            //------------------------------------------------------------
            //	Validate parameter
            //------------------------------------------------------------
            Guard.ArgumentNotNull(entry, "entry");
            Guard.ArgumentNotNull(source, "source");
            Guard.ArgumentNotNull(manager, "manager");
            Guard.ArgumentNotNull(settings, "settings");

            //------------------------------------------------------------
            //	Attempt to fill syndication resource
            //------------------------------------------------------------
            AtomUtility.FillCommonObjectAttributes(entry, source);

            XPathNavigator idNavigator      = source.SelectSingleNode("atom:id", manager);
            XPathNavigator titleNavigator   = source.SelectSingleNode("atom:title", manager);
            XPathNavigator updatedNavigator = source.SelectSingleNode("atom:updated", manager);

            if (idNavigator != null)
            {
                entry.Id    = new AtomId();
                entry.Id.Load(idNavigator, settings);
            }

            if (titleNavigator != null)
            {
                entry.Title = new AtomTextConstruct();
                entry.Title.Load(titleNavigator, settings);
            }

            if (updatedNavigator != null)
            {
                DateTime updatedOn;
                if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(updatedNavigator.Value, out updatedOn))
                {
                    entry.UpdatedOn = updatedOn;
                }
            }

            Atom10SyndicationResourceAdapter.FillEntryOptionals(entry, source, manager, settings);
            Atom10SyndicationResourceAdapter.FillEntryCollections(entry, source, manager, settings);

            SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
            adapter.Fill(entry, manager);
        }
        /// <summary>
        /// Modifies the <see cref="AtomEntry"/> collection entities to match the supplied <see cref="XPathNavigator"/> data source.
        /// </summary>
        /// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
        /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
        /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
        /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
        /// <remarks>
        ///     This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomEntry"/>.
        /// </remarks>
        /// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
        private static void FillEntryCollections(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
        {
            //------------------------------------------------------------
            //	Validate parameter
            //------------------------------------------------------------
            Guard.ArgumentNotNull(entry, "entry");
            Guard.ArgumentNotNull(source, "source");
            Guard.ArgumentNotNull(manager, "manager");
            Guard.ArgumentNotNull(settings, "settings");

            //------------------------------------------------------------
            //	Attempt to extract syndication information
            //------------------------------------------------------------
            XPathNodeIterator authorIterator        = source.Select("atom:author", manager);
            XPathNodeIterator categoryIterator      = source.Select("atom:category", manager);
            XPathNodeIterator contributorIterator   = source.Select("atom:contributor", manager);
            XPathNodeIterator linkIterator          = source.Select("atom:link", manager);

            if (authorIterator != null && authorIterator.Count > 0)
            {
                while (authorIterator.MoveNext())
                {
                    AtomPersonConstruct author  = new AtomPersonConstruct();
                    if (author.Load(authorIterator.Current, settings))
                    {
                        entry.Authors.Add(author);
                    }
                }
            }

            if (categoryIterator != null && categoryIterator.Count > 0)
            {
                while (categoryIterator.MoveNext())
                {
                    AtomCategory category   = new AtomCategory();
                    if (category.Load(categoryIterator.Current, settings))
                    {
                        entry.Categories.Add(category);
                    }
                }
            }

            if (contributorIterator != null && contributorIterator.Count > 0)
            {
                while (contributorIterator.MoveNext())
                {
                    AtomPersonConstruct contributor = new AtomPersonConstruct();
                    if (contributor.Load(contributorIterator.Current, settings))
                    {
                        entry.Contributors.Add(contributor);
                    }
                }
            }

            if (linkIterator != null && linkIterator.Count > 0)
            {
                while (linkIterator.MoveNext())
                {
                    AtomLink link   = new AtomLink();
                    if (link.Load(linkIterator.Current, settings))
                    {
                        entry.Links.Add(link);
                    }
                }
            }
        }
        /// <summary>
        /// Updates information about a syndication resource in the data source.
        /// </summary>
        /// <param name="request">The url from the syndication data source for the resource to be updated.</param>
        /// <param name="entry">
        ///     An object that implements the <see cref="ISyndicationResource"/> interface that represents the updated information for the resource.
        /// </param>
        public virtual AtomEntry UpdateEntry(SDataBaseRequest request, AtomEntry entry)
        {
            Guard.ArgumentNotNull(request, "request");
            Guard.ArgumentNotNull(entry, "entry");

            try
            {
                var url = request.ToString();
                var eTag = entry.GetSDataHttpETag();
                var batchItem = new SDataBatchRequestItem
                                {
                                    Url = url,
                                    Method = HttpMethod.Put,
                                    Entry = entry,
                                    ETag = eTag
                                };

                if (BatchProcess.Instance.AddToBatch(batchItem))
                {
                    return null;
                }

                var operation = new RequestOperation(HttpMethod.Put, entry) {ETag = eTag};
                return ExecuteEntryRequest(url, operation);
            }
            catch (SDataClientException)
            {
                throw;
            }
            catch (Exception ex)
            {
                throw new SDataClientException(ex.Message, ex);
            }
        }
        /// <summary>
        /// Creates a new <see cref="AtomEntry"/> instance using the specified <see cref="Uri"/>, <see cref="ICredentials"/>, <see cref="IWebProxy"/>, and <see cref="SyndicationResourceLoadSettings"/> object.
        /// </summary>
        /// <param name="source">A <see cref="Uri"/> that represents the URL of the syndication resource XML data.</param>
        /// <param name="options">A <see cref="WebRequestOptions"/> that holds options that should be applied to web requests.</param>
        /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the <see cref="AtomEntry"/> instance. This value can be <b>null</b>.</param>
        /// <returns>An <see cref="AtomEntry"/> object loaded using the <paramref name="source"/> data.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="FormatException">The <paramref name="source"/> data does not conform to the expected syndication content format. In this case, the entry remains empty.</exception>
        public static AtomEntry Create(Uri source, WebRequestOptions options, SyndicationResourceLoadSettings settings)
        {
            //------------------------------------------------------------
            //	Local members
            //------------------------------------------------------------
            AtomEntry syndicationResource = new AtomEntry();

            //------------------------------------------------------------
            //	Validate parameters
            //------------------------------------------------------------
            Guard.ArgumentNotNull(source, "source");

            //------------------------------------------------------------
            //	Create new instance using supplied parameters
            //------------------------------------------------------------
            syndicationResource.Load(source, options, settings);

            return syndicationResource;
        }
 private static AtomEntry LoadEntryContent(Stream stream)
 {
     var entry = new AtomEntry();
     entry.Load(stream);
     return entry;
 }
        private bool DeleteEntry(string url, AtomEntry entry)
        {
            try
            {
                var eTag = entry != null ? entry.GetSDataHttpETag() : null;
                var batchItem = new SDataBatchRequestItem
                                {
                                    Url = url,
                                    Method = HttpMethod.Delete,
                                    ETag = eTag
                                };

                if (BatchProcess.Instance.AddToBatch(batchItem))
                {
                    return true;
                }

                var operation = new RequestOperation(HttpMethod.Delete) {ETag = eTag};
                var response = ExecuteRequest(url, operation, MediaType.AtomEntry, MediaType.Xml);
                return response.StatusCode == HttpStatusCode.OK;
            }
            catch (Exception ex)
            {
                throw new SDataClientException(ex.Message, ex);
            }
        }
 /// <summary>
 /// Updates information about a syndication resource in the data source.
 /// </summary>
 /// <param name="request">The url from the syndication data source for the resource to be updated.</param>
 /// <param name="entry">
 ///     An object that implements the <see cref="ISyndicationResource"/> interface that represents the updated information for the resource.
 /// </param>
 public virtual AtomEntry UpdateEntry(SDataBaseRequest request, AtomEntry entry)
 {
     Guard.ArgumentNotNull(request, "request");
     return UpdateEntry(request.ToString(), entry);
 }
 /// <summary>
 /// Adds a new syndication resource to the data source.
 /// </summary>
 /// <param name="request">The request that identifies the resource within the syndication data source.</param>
 /// <param name="entry">The entry that should be created.</param>
 public virtual AtomEntry CreateEntry(SDataBaseRequest request, AtomEntry entry)
 {
     Guard.ArgumentNotNull(request, "request");
     var requestUrl = request.ToString();
     return CreateEntry(requestUrl, entry);
 }
 /// <summary>
 /// initializes the single resource request and loads the atom entry
 /// </summary>
 /// <remarks>this should be used with the atom entry returned from the 
 /// SDataTemplateResourceRequest</remarks>
 /// <param name="service"></param>
 /// <param name="entry"></param>
 public SDataSingleResourceRequest(ISDataService service, AtomEntry entry)
     : base(service)
 {
     Entry = entry;
 }
        /// <summary>
        /// Modifies the <see cref="AtomEntry"/> optional entities to match the supplied <see cref="XPathNavigator"/> data source.
        /// </summary>
        /// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
        /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
        /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
        /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
        /// <remarks>
        ///     This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomEntry"/>.
        /// </remarks>
        /// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
        private static void FillEntryOptionals(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
        {
            //------------------------------------------------------------
            //	Validate parameter
            //------------------------------------------------------------
            Guard.ArgumentNotNull(entry, "entry");
            Guard.ArgumentNotNull(source, "source");
            Guard.ArgumentNotNull(manager, "manager");
            Guard.ArgumentNotNull(settings, "settings");

            //------------------------------------------------------------
            //	Attempt to extract syndication information
            //------------------------------------------------------------
            XPathNavigator contentNavigator     = source.SelectSingleNode("atom:content", manager);
            XPathNavigator publishedNavigator   = source.SelectSingleNode("atom:published", manager);
            XPathNavigator rightsNavigator      = source.SelectSingleNode("atom:rights", manager);
            XPathNavigator sourceNavigator      = source.SelectSingleNode("atom:source", manager);
            XPathNavigator summaryNavigator     = source.SelectSingleNode("atom:summary", manager);

            if (contentNavigator != null)
            {
                entry.Content   = new AtomContent();
                entry.Content.Load(contentNavigator, settings);
            }

            if (publishedNavigator != null)
            {
                DateTime publishedOn;
                if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(publishedNavigator.Value, out publishedOn))
                {
                    entry.PublishedOn   = publishedOn;
                }
            }

            if (rightsNavigator != null)
            {
                entry.Rights = new AtomTextConstruct();
                entry.Rights.Load(rightsNavigator, settings);
            }

            if (sourceNavigator != null)
            {
                entry.Source    = new AtomSource();
                entry.Source.Load(sourceNavigator, settings);
            }

            if (summaryNavigator != null)
            {
                entry.Summary   = new AtomTextConstruct();
                entry.Summary.Load(summaryNavigator, settings);
            }
        }
        /// <summary>
        /// Modifies the <see cref="AtomFeed"/> collection entities to match the supplied <see cref="XPathNavigator"/> data source.
        /// </summary>
        /// <param name="feed">The <see cref="AtomFeed"/> to be filled.</param>
        /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
        /// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
        /// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
        /// <remarks>
        ///     This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="AtomFeed"/>.
        /// </remarks>
        /// <exception cref="ArgumentNullException">The <paramref name="feed"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
        /// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
        private static void FillFeedCollections(AtomFeed feed, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
        {
            //------------------------------------------------------------
            //	Validate parameter
            //------------------------------------------------------------
            Guard.ArgumentNotNull(feed, "feed");
            Guard.ArgumentNotNull(source, "source");
            Guard.ArgumentNotNull(manager, "manager");
            Guard.ArgumentNotNull(settings, "settings");

            //------------------------------------------------------------
            //	Attempt to extract syndication information
            //------------------------------------------------------------
            XPathNodeIterator authorIterator        = source.Select("atom:author", manager);
            XPathNodeIterator categoryIterator      = source.Select("atom:category", manager);
            XPathNodeIterator contributorIterator   = source.Select("atom:contributor", manager);
            XPathNodeIterator linkIterator          = source.Select("atom:link", manager);
            XPathNodeIterator entryIterator         = source.Select("atom:entry", manager);

            if (authorIterator != null && authorIterator.Count > 0)
            {
                while (authorIterator.MoveNext())
                {
                    AtomPersonConstruct author  = new AtomPersonConstruct();
                    if (author.Load(authorIterator.Current, settings))
                    {
                        feed.Authors.Add(author);
                    }
                }
            }

            if (categoryIterator != null && categoryIterator.Count > 0)
            {
                while (categoryIterator.MoveNext())
                {
                    AtomCategory category   = new AtomCategory();
                    if (category.Load(categoryIterator.Current, settings))
                    {
                        feed.Categories.Add(category);
                    }
                }
            }

            if (contributorIterator != null && contributorIterator.Count > 0)
            {
                while (contributorIterator.MoveNext())
                {
                    AtomPersonConstruct contributor = new AtomPersonConstruct();
                    if (contributor.Load(contributorIterator.Current, settings))
                    {
                        feed.Contributors.Add(contributor);
                    }
                }
            }

            if (entryIterator != null && entryIterator.Count > 0)
            {
                int counter = 0;
                while (entryIterator.MoveNext())
                {
                    AtomEntry entry = new AtomEntry();
                    counter++;

                    Atom10SyndicationResourceAdapter.FillEntry(entry, entryIterator.Current, manager, settings);

                    if (settings.RetrievalLimit != 0 && counter > settings.RetrievalLimit)
                    {
                        break;
                    }

                    ((Collection<AtomEntry>)feed.Entries).Add(entry);
                }
            }

            if (linkIterator != null && linkIterator.Count > 0)
            {
                while (linkIterator.MoveNext())
                {
                    AtomLink link   = new AtomLink();
                    if (link.Load(linkIterator.Current, settings))
                    {
                        feed.Links.Add(link);
                    }
                }
            }
        }
        /// <summary>
        /// Reads resource information from the data source based on the URL and the ETag of the specified entry.
        /// </summary>
        /// <param name="request"></param>
        /// <param name="entry"></param>
        /// <returns></returns>
        public virtual AtomEntry ReadEntry(SDataBaseRequest request, AtomEntry entry)
        {
            Guard.ArgumentNotNull(request, "request");

            try
            {
                var requestUrl = request.ToString();
                var eTag = entry != null ? entry.GetSDataHttpETag() : null;
                var batchItem = new SDataBatchRequestItem
                                {
                                    Url = requestUrl,
                                    Method = HttpMethod.Get,
                                    ETag = eTag
                                };

                if (BatchProcess.Instance.AddToBatch(batchItem))
                {
                    return null;
                }

                var operation = new RequestOperation(HttpMethod.Get) {ETag = eTag};
                var response = ExecuteRequest(requestUrl, operation, MediaType.AtomEntry, MediaType.Xml);
                entry = (AtomEntry) response.Content;

                if (!string.IsNullOrEmpty(response.ETag))
                {
                    entry.SetSDataHttpETag(response.ETag);
                }

                return entry;
            }
            catch (Exception ex)
            {
                throw new SDataClientException(ex.Message, ex);
            }
        }
        /// <summary>
        /// Adds the supplied <see cref="AtomEntry"/> to the current instance's <see cref="Entries"/> collection.
        /// </summary>
        /// <param name="entry">The <see cref="AtomEntry"/> to be added.</param>
        /// <returns><b>true</b> if the <see cref="AtomEntry"/> was added to the <see cref="Entries"/> collection, otherwise <b>false</b>.</returns>
        /// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
        public bool AddEntry(AtomEntry entry)
        {
            //------------------------------------------------------------
            //	Local members
            //------------------------------------------------------------
            bool wasAdded   = false;

            //------------------------------------------------------------
            //	Validate parameter
            //------------------------------------------------------------
            Guard.ArgumentNotNull(entry, "entry");

            //------------------------------------------------------------
            //	Add entry to collection
            //------------------------------------------------------------
            ((Collection<AtomEntry>)this.Entries).Add(entry);
            wasAdded    = true;

            return wasAdded;
        }
        private AtomEntry CreateEntry(string url, AtomEntry entry)
        {
            Guard.ArgumentNotNull(entry, "entry");

            try
            {
                var batchItem = new SDataBatchRequestItem
                                {
                                    Url = url,
                                    Method = HttpMethod.Post,
                                    Entry = entry
                                };

                if (BatchProcess.Instance.AddToBatch(batchItem))
                {
                    return null;
                }

                var operation = new RequestOperation(HttpMethod.Post, entry);
                var response = ExecuteRequest(url, operation, MediaType.AtomEntry, MediaType.Xml);
                var result = response.Content as AtomEntry;

                if (result == null)
                {
                    var feedResult = response.Content as AtomFeed;
                    if (feedResult != null)
                    {
                        result = feedResult.Entries.FirstOrDefault();
                    }
                }

                if (!string.IsNullOrEmpty(response.ETag) && result != null)
                {
                    result.SetSDataHttpETag(response.ETag);
                }

                return result;
            }
            catch (Exception ex)
            {
                throw new SDataClientException(ex.Message, ex);
            }
        }
        /// <summary>
        /// Removes the supplied <see cref="AtomEntry"/> from the current instance's <see cref="Entries"/> collection.
        /// </summary>
        /// <param name="entry">The <see cref="AtomEntry"/> to be removed.</param>
        /// <returns><b>true</b> if the <see cref="AtomEntry"/> was removed from the <see cref="Entries"/> collection, otherwise <b>false</b>.</returns>
        /// <remarks>
        ///     If the <see cref="Entries"/> collection of the current instance does not contain the specified <see cref="AtomEntry"/>, will return <b>false</b>.
        /// </remarks>
        /// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
        public bool RemoveEntry(AtomEntry entry)
        {
            //------------------------------------------------------------
            //	Local members
            //------------------------------------------------------------
            bool wasRemoved = false;

            //------------------------------------------------------------
            //	Validate parameter
            //------------------------------------------------------------
            Guard.ArgumentNotNull(entry, "entry");

            //------------------------------------------------------------
            //	Remove entry from collection
            //------------------------------------------------------------
            if (((Collection<AtomEntry>)this.Entries).Contains(entry))
            {
                ((Collection<AtomEntry>)this.Entries).Remove(entry);
                wasRemoved  = true;
            }

            return wasRemoved;
        }
        private AtomEntry UpdateEntry(string url, AtomEntry entry)
        {
            Guard.ArgumentNotNull(entry, "entry");

            try
            {
                var eTag = entry.GetSDataHttpETag();
                var batchItem = new SDataBatchRequestItem
                                {
                                    Url = url,
                                    Method = HttpMethod.Put,
                                    Entry = entry,
                                    ETag = eTag
                                };

                if (BatchProcess.Instance.AddToBatch(batchItem))
                {
                    return null;
                }

                var operation = new RequestOperation(HttpMethod.Put, entry) {ETag = eTag};
                var response = ExecuteRequest(url, operation, MediaType.AtomEntry, MediaType.Xml);
                entry = (AtomEntry) response.Content;

                if (!string.IsNullOrEmpty(response.ETag))
                {
                    entry.SetSDataHttpETag(response.ETag);
                }

                return entry;
            }
            catch (Exception ex)
            {
                throw new SDataClientException(ex.Message, ex);
            }
        }
        private void DisplayEntry(AtomEntry entry)
        {
            _sdataSingleResourceRequest.Entry = entry;
            var exists = entry != null;

            btnSingleCreate.Enabled = exists;
            btnSingleUpdate.Enabled = exists;
            btnSingleDelete.Enabled = exists;

            if (exists)
            {
                var uri = entry.Id.Uri.OriginalString;
                var start = uri.IndexOf("(");
                var end = uri.IndexOf(")", start);
                tbSingleResourceSelector.Text = uri.Substring(start, end + 1 - start);

                // show it in the grid
                singlePayloadGrid.SelectedObject = entry.GetSDataPayload();
            }
            else
            {
                tbSingleResourceSelector.Text = null;
                singlePayloadGrid.SelectedObject = null;
            }
        }
        private RequestOperation CreateBatchOperation()
        {
            var uri = new SDataUri(Uri);

            if (uri.PathSegments.Length != 4)
            {
                throw new InvalidOperationException("Batch requests can only be made on collection end points");
            }

            var feed = new AtomFeed();
            var batchOp = new RequestOperation(HttpMethod.Post, feed);

            foreach (var op in _operations)
            {
                AtomEntry entry;

                if (op.Resource == null)
                {
                    if (op.Method != HttpMethod.Post)
                    {
                        throw new InvalidOperationException("A predicate must be specified for GET, PUT and DELETE batch requests");
                    }

                    var entryUri = new SDataUri(uri) {CollectionPredicate = op.Predicate};
                    entry = new AtomEntry {Id = new AtomId(entryUri.Uri)};
                }
                else
                {
                    entry = op.Resource as AtomEntry;

                    if (entry == null)
                    {
                        throw new InvalidOperationException("Only atom entry resources can be submitted in batch requests");
                    }
                }

                entry.SetSDataHttpMethod(op.Method);

                if (!string.IsNullOrEmpty(op.ETag))
                {
                    entry.SetSDataHttpIfMatch(op.ETag);
                }

                feed.AddEntry(entry);

                foreach (var file in op.Files)
                {
                    batchOp.Files.Add(file);
                }
            }

            return batchOp;
        }
        /// <summary>
        /// Removes a resource from the syndication data source.
        /// </summary>
        /// <param name="request">The request from the syndication data source for the resource to be removed.</param>
        /// <param name="entry">the resource that is being deleted</param>
        /// <returns><b>true</b> if the syndication resource was successfully deleted; otherwise, <b>false</b>.</returns>
        public virtual bool DeleteEntry(SDataBaseRequest request, AtomEntry entry)
        {
            Guard.ArgumentNotNull(request, "request");

            try
            {
                var url = request.ToString();
                var eTag = entry != null ? entry.GetSDataHttpETag() : null;
                var batchItem = new SDataBatchRequestItem
                                {
                                    Url = url,
                                    Method = HttpMethod.Delete,
                                    ETag = eTag
                                };

                if (BatchProcess.Instance.AddToBatch(batchItem))
                {
                    return true;
                }

                var operation = new RequestOperation(HttpMethod.Delete) {ETag = eTag};
                var response = ExecuteRequest(url, operation, MediaType.AtomEntry, MediaType.Xml);
                return response.StatusCode == HttpStatusCode.OK;
            }
            catch (Exception ex)
            {
                throw new SDataClientException(ex.Message, ex);
            }
        }