public override SyncFeed GetFeed()
{
bool includeUuid;
string whereClause = string.Empty;
OleDbParameter[] oleDbParameters = null;
if (this is IEntityQueryWrapper)
{
QueryFilterBuilder queryFilterBuilder = new QueryFilterBuilder((IEntityQueryWrapper)this);
queryFilterBuilder.BuildSqlStatement(_context, out whereClause, out oleDbParameters);
}
SyncFeed feed = new SyncFeed();
feed.Title = _resourceKind.ToString() + ": " + DateTime.Now.ToString();
Token emptyToken = new Token();
List <Identity> identities = new List <Identity>();
if (String.IsNullOrEmpty(_context.ResourceKey))
{
identities = _entity.GetAll(_context.Config, whereClause, oleDbParameters);
}
else
{
identities.Add(new Identity(_entity.EntityName, _context.ResourceKey));
}
int totalResult = identities.Count;
#region PAGING & OPENSEARCH
/* PAGING */
feed.Links = FeedMetadataHelpers.CreatePageFeedLinks(_context, totalResult, FeedMetadataHelpers.RequestKeywordType.none);
/* OPENSEARCH */
PageController pageController = FeedMetadataHelpers.GetPageLinkBuilder(_context, totalResult, FeedMetadataHelpers.RequestKeywordType.none);
feed.Opensearch_ItemsPerPageElement = pageController.GetOpensearch_ItemsPerPageElement();
feed.Opensearch_StartIndexElement = pageController.GetOpensearch_StartIndexElement();
feed.Opensearch_TotalResultsElement = pageController.GetOpensearch_TotalResultsElement();
#endregion
feed.Id = _context.SdataUri.ToString();
string tmpValue;
// ?includeUuid
includeUuid = false; // default value, but check for settings now
if (_context.SdataUri.QueryArgs.TryGetValue("includeUuid", out tmpValue))
{
includeUuid = System.Xml.XmlConvert.ToBoolean(tmpValue);
}
ICorrelatedResSyncInfoStore correlatedResSyncStore = null;
if (includeUuid)
{
// get store to request the correlations
correlatedResSyncStore = RequestReceiver.NorthwindAdapter.StoreLocator.GetCorrelatedResSyncStore(_context.SdataContext);
}
for (int pageIndex = pageController.StartIndex; pageIndex <= pageController.LastIndex; pageIndex++)
//for (int index = startIndex; index < startIndex + count; index++)
{
int zeroBasedIndex = pageIndex - 1;
Identity identity = identities[zeroBasedIndex];
AccountDocument accountDocument = (AccountDocument)_entity.GetDocument(identity, emptyToken, _context.Config);
if (accountDocument.LogState == LogState.Deleted)
{
continue;
}
SyncFeedEntry entry = new SyncFeedEntry();
if (accountDocument.addresses.documents.Count == 0)
{
return(null);
}
entry.Id = String.Format("{0}{1}('{2}')", _context.DatasetLink, _resourceKind.ToString(), identity.Id);
entry.Title = String.Format("{0}: {1}", _resourceKind.ToString(), identity.Id);
entry.Updated = DateTime.Now;
if (_context.SdataUri.Precedence == null)
{
List <SyncFeedEntryLink> links;
Document document = accountDocument.addresses.documents[0];
entry.Payload = GetTransformedPayload(document, out links);
string taUuid = GetTradingAccountUuid(accountDocument.Id);
if (!String.IsNullOrEmpty(taUuid))
{
SyncFeedEntryLink tradingAccountLink = SyncFeedEntryLink.CreateRelatedLink(
String.Format("{0}{1}('{2}')", _context.DatasetLink, SupportedResourceKinds.tradingAccounts.ToString(), accountDocument.Id),
SupportedResourceKinds.tradingAccounts.ToString(),
_tradingAccountUuidPayloadPath, taUuid);
links.Add(tradingAccountLink);
}
entry.SyncLinks = links;
}
if (includeUuid)
{
CorrelatedResSyncInfo[] infos = correlatedResSyncStore.GetByLocalId(_context.ResourceKind.ToString(), new string[] { identity.Id });
entry.Uuid = (infos.Length > 0) ? infos[0].ResSyncInfo.Uuid : Guid.Empty;
}
if (entry != null)
{
feed.Entries.Add(entry);
}
}
return(feed);
}
public void DoWork(IRequest request)
{
EntryRequestType entryRequestType;
string resourceKindName;
ICorrelatedResSyncInfoStore correlatedResSyncStore;
bool includeDataPayloads; //?includePayloads value
CorrelatedResSyncInfo[] correlatedResSyncInfos;
int totalResult;
#region initialization
// multi or single entry request?
entryRequestType = (String.IsNullOrEmpty(_requestContext.ResourceKey)) ? EntryRequestType.Multi : EntryRequestType.Single;
resourceKindName = _requestContext.ResourceKind.ToString();
string tmpValue;
// ?includePayloads
includeDataPayloads = false; // default value, but check for settings now
if (_requestContext.SdataUri.QueryArgs.TryGetValue("includePayload", out tmpValue))
{
includeDataPayloads = System.Xml.XmlConvert.ToBoolean(tmpValue);
}
// get store to request the correlations
correlatedResSyncStore = RequestReceiver.NorthwindAdapter.StoreLocator.GetCorrelatedResSyncStore(_requestContext.SdataContext);
#endregion
// receive correlated resource synchronization entries
if (entryRequestType == EntryRequestType.Multi)
{
int pageNumber = FeedMetadataHelpers.GetPageNumber(_requestContext);
correlatedResSyncInfos = correlatedResSyncStore.GetPaged(resourceKindName, pageNumber, FeedMetadataHelpers.DEFAULT_ITEMS_PER_PAGE, out totalResult);
}
else
{
Guid uuid = (Guid)TypeDescriptor.GetConverter(typeof(Guid)).ConvertFrom(_requestContext.ResourceKey);
correlatedResSyncInfos = correlatedResSyncStore.GetByUuid(resourceKindName, new Guid[] { uuid });
totalResult = correlatedResSyncInfos.Length;
}
// Create the feed
SyncFeed feed = new SyncFeed();
// initialize the feed
feed.Id = FeedMetadataHelpers.BuildBaseUrl(_requestContext, FeedMetadataHelpers.RequestKeywordType.linked);
feed.Title = string.Format("{0} Linking Feed", resourceKindName);
#region PAGING & OPENSEARCH
/* PAGING */
feed.Links = FeedMetadataHelpers.CreatePageFeedLinks(_requestContext, totalResult, FeedMetadataHelpers.RequestKeywordType.linked);
/* OPENSEARCH */
PageController pageLinkBuilder = FeedMetadataHelpers.GetPageLinkBuilder(_requestContext, totalResult, FeedMetadataHelpers.RequestKeywordType.linked);
feed.Opensearch_ItemsPerPageElement = pageLinkBuilder.GetOpensearch_ItemsPerPageElement();
feed.Opensearch_StartIndexElement = pageLinkBuilder.GetOpensearch_StartIndexElement();
feed.Opensearch_TotalResultsElement = pageLinkBuilder.GetOpensearch_TotalResultsElement();
#endregion
feed.FeedType = (entryRequestType == EntryRequestType.Multi) ? FeedType.Linked : FeedType.LinkedSingle;
IEntityWrapper wrapper = null;
if (includeDataPayloads)
{
wrapper = EntityWrapperFactory.Create(_requestContext.ResourceKind, _requestContext);
}
for (int i = 0; i < correlatedResSyncInfos.Length; i++)
{
SyncFeedEntry entry = null;
if (includeDataPayloads)
{
entry = wrapper.GetFeedEntry(correlatedResSyncInfos[i].LocalId);
}
else
{
entry = new SyncFeedEntry();
}
entry.Id = FeedMetadataHelpers.BuildLinkedEntryUrl(_requestContext, correlatedResSyncInfos[i].ResSyncInfo.Uuid);
entry.Title = FeedMetadataHelpers.BuildLinkedEntryTitle(_requestContext, correlatedResSyncInfos[i].ResSyncInfo.Uuid);
#region LINKED ELEMENT
LinkedElement linkedElement = new LinkedElement();
linkedElement.Resource = FeedMetadataHelpers.BuildEntryResourceUrl(_requestContext, correlatedResSyncInfos[i].LocalId);
linkedElement.Uuid = correlatedResSyncInfos[i].ResSyncInfo.Uuid;
entry.Linked = linkedElement;
#endregion
feed.Entries.Add(entry);
}
request.Response.Serializer = new SyncFeedSerializer();
request.Response.Feed = (IFeed)feed;
request.Response.ContentType = (entryRequestType == EntryRequestType.Multi) ? MediaType.Atom : MediaType.AtomEntry;
}
public void Create(FeedEntry entry)
{
// only atom entry supported!!!
if (_request.ContentType != Sage.Common.Syndication.MediaType.AtomEntry)
{
throw new RequestException("Atom entry content type expected");
}
string requestEndPointUrl;
RequestContext entryResourceAsRequestContext;
string url; // The url that references an existing resource
string localId; // will be parsed from urlAttrValue and set to the key attribute of the result resource payload
Guid uuid; // the new uuid
if (null == entry)
{
throw new RequestException("sdata payload element missing");
}
// the consumer MUST provide an sdata:url attribute that references an existing resource.
url = entry.Uri;
if (string.IsNullOrEmpty(url))
{
throw new RequestException("sdata url attribute missing for resource payload element.");
}
// Parse the url of thew url attribute to get the local id.
// Additionally we check for equality of the urls of the request url and
// in the linked element up to the resourceKind.
requestEndPointUrl = _requestContext.OriginEndPoint;
entryResourceAsRequestContext = new RequestContext(new Sage.Common.Syndication.SDataUri(url)); // TODO: not really nice here.
string linkedResourceUrl = entryResourceAsRequestContext.OriginEndPoint;
if (!string.Equals(requestEndPointUrl, linkedResourceUrl, StringComparison.InvariantCultureIgnoreCase))
{
throw new RequestException("Request url and linked entry resource not matching.");
}
string resourceKindName = _requestContext.ResourceKind.ToString();
localId = entryResourceAsRequestContext.ResourceKey;
ICorrelatedResSyncInfoStore correlatedResSyncInfoStore = NorthwindAdapter.StoreLocator.GetCorrelatedResSyncStore(_requestContext.SdataContext);
CheckExisting(correlatedResSyncInfoStore, localId);
// try to get the new uuid from uuid attribute
// if this attribute is not set a new one is created
if (null == entry.UUID || entry.UUID == Guid.Empty)
{
uuid = Guid.NewGuid();
}
else
{
uuid = entry.UUID;
}
// store a new correlation entry to the sync store
ResSyncInfo newResSyncInfo = new ResSyncInfo(uuid, requestEndPointUrl, 0, string.Empty, DateTime.Now);
CorrelatedResSyncInfo newInfo = new CorrelatedResSyncInfo(localId, newResSyncInfo);
correlatedResSyncInfoStore.Add(resourceKindName, newInfo);
// If the service consumer only needs to retrieve the URL, not the actual payload,
// it may do so by adding an empty select parameter to its request:
// a) select parameter not exist -> return deep resource payload
// b) select exists and empty -> return no resource payload
// c) select exists and not empty -> return deep resource payload as we do not yet support payload filtering
// with select parameter.
string tmpValue;
// ?select
bool includeResourcePayloads = true; // default value, but check for select parameter now
if (_requestContext.SdataUri.QueryArgs.TryGetValue("select", out tmpValue))
{
if (string.IsNullOrEmpty(_requestContext.SdataUri.QueryArgs["select"]))
{
includeResourcePayloads = false;
}
}
// Create an entity wrapper if resource data should be requested. Otherwise
// leave wrapper null.
IFeedEntryEntityWrapper wrapper = null;
//if (includeResourcePayloads) //TODO: Comment this in as soon as there is a possibility to send empty payload objects
wrapper = FeedEntryWrapperFactory.Create(_requestContext.ResourceKind, _requestContext);
/* Create the response entry */
_request.Response.FeedEntry = (FeedEntry)this.BuildFeedEntryForCorrelation(newInfo, wrapper);
_request.Response.ContentType = MediaType.AtomEntry;
_request.Response.StatusCode = System.Net.HttpStatusCode.Created;
_request.Response.Protocol.SendUnknownResponseHeader("location", FeedMetadataHelpers.BuildLinkedEntryUrl(_requestContext, uuid));
}
public void DoWork(IRequest request)
{
// only atom entry supported!!!
if (request.ContentType != Sage.Common.Syndication.MediaType.AtomEntry)
{
throw new RequestException("Atom entry content type expected");
}
// deserialize the request stream to a SyncFeedEntry
SyncFeedEntry entry = new SyncFeedEntry();
XmlReader reader = XmlReader.Create(request.Stream);
reader.MoveToContent();
entry.ReadXml(reader, typeof(SyncDigestPayload));
if (null == entry.Linked)
{
throw new RequestException("Invalid content: element 'linked' missing");
}
// We check for equality of the urls of the request url and
// in the linked element up to the resourceKind.
string requestEndpointUrl = _requestContext.OriginEndPoint;
RequestContext entryResourceAsRequestContext = new RequestContext(new Sage.Common.Syndication.SDataUri(entry.Linked.Resource)); // TODO: not really nice here.
string linkedResourceUrl = entryResourceAsRequestContext.OriginEndPoint;
if (!string.Equals(requestEndpointUrl, linkedResourceUrl, StringComparison.InvariantCultureIgnoreCase))
{
throw new RequestException("Request url and linked entry resource not matching.");
}
string resourceKindName = _requestContext.ResourceKind.ToString();
Guid currentUuid = (Guid)TypeDescriptor.GetConverter(typeof(Guid)).ConvertFrom(_requestContext.ResourceKey);
Guid newUuid = entry.Linked.Uuid;
string newLocalId = entryResourceAsRequestContext.SdataUri.CollectionPredicate;
// update the correlation entry in the sync store.
// if the uuid should be updated we have to remove the current correlation and then add a new one.
// otherwise we update the current correlation.
ICorrelatedResSyncInfoStore correlatedResSyncInfoStore = RequestReceiver.NorthwindAdapter.StoreLocator.GetCorrelatedResSyncStore(_requestContext.SdataContext);
// create the target correlation
ResSyncInfo targetResSyncInfo = new ResSyncInfo(newUuid, requestEndpointUrl, 0, string.Empty, DateTime.Now);
CorrelatedResSyncInfo targetInfo = new CorrelatedResSyncInfo(newLocalId, targetResSyncInfo);
if (currentUuid == newUuid)
{
correlatedResSyncInfoStore.Update(resourceKindName, targetInfo);
}
else
{
correlatedResSyncInfoStore.Delete(resourceKindName, currentUuid);
correlatedResSyncInfoStore.Add(resourceKindName, targetInfo);
}
// create response
SyncFeed feed = new SyncFeed();
feed.FeedType = FeedType.LinkedSingle;
// create entry
SyncFeedEntry responseEntry = new SyncFeedEntry();
responseEntry.Id = FeedMetadataHelpers.BuildLinkedEntryUrl(_requestContext, targetInfo.ResSyncInfo.Uuid);
responseEntry.Title = FeedMetadataHelpers.BuildLinkedEntryTitle(_requestContext, targetInfo.ResSyncInfo.Uuid);
LinkedElement linkedElement = new LinkedElement();
linkedElement.Resource = FeedMetadataHelpers.BuildEntryResourceUrl(_requestContext, targetInfo.LocalId);
linkedElement.Uuid = targetInfo.ResSyncInfo.Uuid;
responseEntry.Linked = linkedElement;
feed.Entries.Add(responseEntry);
request.Response.Serializer = new SyncFeedSerializer();
request.Response.Feed = (IFeed)feed;
request.Response.ContentType = MediaType.AtomEntry;
}
public void DoWork(IRequest request)
{
// only atom entry supported!!!
if (request.ContentType != Sage.Common.Syndication.MediaType.AtomEntry)
{
throw new RequestException("Atom entry content type expected");
}
// deserialize the request stream to a SyncFeedEntry
SyncFeedEntry entry = new SyncFeedEntry();
XmlReader reader = XmlReader.Create(request.Stream);
reader.MoveToContent();
entry.ReadXml(reader, typeof(SyncDigestPayload));
if (null == entry.Linked)
{
throw new RequestException("Invalid content: element 'linked' missing");
}
// Parse the resource url to get the local id.
// Additionally we check for equality of the urls of the request url and
// in the linked element up to the resourceKind.
string requestEndpointUrl = _requestContext.OriginEndPoint;
RequestContext entryResourceAsRequestContext = new RequestContext(new Sage.Common.Syndication.SDataUri(entry.Linked.Resource)); // TODO: not really nice here.
string linkedResourceUrl = entryResourceAsRequestContext.OriginEndPoint;
if (!string.Equals(requestEndpointUrl, linkedResourceUrl, StringComparison.InvariantCultureIgnoreCase))
{
throw new RequestException("Request url and linked entry resource not matching.");
}
string resourceKindName = _requestContext.ResourceKind.ToString();
string localId = entryResourceAsRequestContext.SdataUri.CollectionPredicate;
Guid uuid = entry.Linked.Uuid;
// store a new correlation entry to the sync store
ICorrelatedResSyncInfoStore correlatedResSyncInfoStore = RequestReceiver.NorthwindAdapter.StoreLocator.GetCorrelatedResSyncStore(_requestContext.SdataContext);
ResSyncInfo newResSyncInfo = new ResSyncInfo(uuid, requestEndpointUrl, 0, string.Empty, DateTime.Now);
CorrelatedResSyncInfo newInfo = new CorrelatedResSyncInfo(localId, newResSyncInfo);
correlatedResSyncInfoStore.Add(resourceKindName, newInfo);
// Set the response values
SyncFeed feed = new SyncFeed();
feed.FeedType = FeedType.LinkedSingle;
SyncFeedEntry feedEntry = new SyncFeedEntry();
feedEntry.Title = FeedMetadataHelpers.BuildLinkedEntryTitle(_requestContext, uuid);
feedEntry.Id = FeedMetadataHelpers.BuildLinkedEntryUrl(_requestContext, uuid);
feedEntry.Updated = newInfo.ResSyncInfo.ModifiedStamp;
feedEntry.Published = newInfo.ResSyncInfo.ModifiedStamp;
feedEntry.Linked = entry.Linked;
feed.Entries.Add(feedEntry);
request.Response.Serializer = new SyncFeedSerializer();
request.Response.Feed = (IFeed)feed;
request.Response.ContentType = MediaType.AtomEntry;
request.Response.StatusCode = System.Net.HttpStatusCode.Created;
request.Response.Protocol.SendUnknownResponseHeader("location", FeedMetadataHelpers.BuildLinkedEntryUrl(_requestContext, uuid));
}
