public ResourceBody GetResourceBody(JToken jBody)
{
switch (jBody.Type)
{
case JTokenType.Array:
var items = from JObject jObject in jBody
select _restItemDataTranslator.ConvertObject(jObject);
return(new CollectionBody(items, null));
case JTokenType.Object:
Debug.Assert(jBody is JObject, "jBody is JObject");
RestItemData itemData = _restItemDataTranslator.ConvertObject((JObject)jBody);
return(new ItemBody(itemData));
case JTokenType.Float:
case JTokenType.String:
case JTokenType.Boolean:
case JTokenType.Integer:
case JTokenType.Date:
case JTokenType.Bytes:
case JTokenType.Guid:
case JTokenType.Uri:
case JTokenType.TimeSpan:
var obj = jBody.ToObject <object>();
return(new ScalarBody(obj));
}
throw new FormatException("Cannot convert body type.");
}
public static async Task <T> As <T>(this Task <RestItemData> itemDataTask)
where T : class, new()
{
RestItemData itemData = await itemDataTask;
return(itemData.As <T>());
}
public async Task ExecuteAdd_IncreasesCount()
{
var newItemData = new RestItemData();
var strategy = new AddToCollectionStrategy();
await strategy.ExecuteAsync(_collectionMock.Object, new TestEndpointContext(), new ItemBody(newItemData));
_collectionMock.Verify(c => c.AddAsync(It.IsAny <RestItemData>()), Times.Once);
}
public async Task <Acknowledgment> EditAsync(RestItemData itemData)
{
using (HttpClient client = HttpClientCreator.Create())
{
HttpResponseMessage response = await client.PutAsync(Path, Serializer.SerializeItemToContent(itemData));
return(await EnsureSuccessAsync(response));
}
}
public async Task ExecuteAddMany_IncreasesCount()
{
var newItemData = new RestItemData();
var strategy = new AddToCollectionStrategy();
var items = new[] { newItemData, newItemData, newItemData };
await strategy.ExecuteAsync(_collectionMock.Object, new TestEndpointContext(), new CollectionBody(items, null));
_collectionMock.Verify(c => c.AddAsync(It.IsAny <RestItemData>()), Times.Exactly(3));
}
public async Task Item_GetWithComplexField_StatusOK()
{
RestItemData data = await _restCollection.GetItem("123").GetDataAsync(new[] { "ID", "Complex" });
var firstComplex = (MyComplexObject)data["Complex"];
Assert.Equal(TestRepositories.ArtistName, firstComplex.Name);
Assert.Equal("at this", firstComplex.Look);
}
private RestItemData CreateAndAddResponseContent(IResponseModifier modifier, Response response)
{
var itemData = new RestItemData();
_fixture.AddManyTo(itemData, 10);
var resourceBody = new ItemBody(itemData);
modifier.AddResource(response, resourceBody);
return(itemData);
}
public Task <RestItemData> GetDataAsync(IEnumerable <string> fieldNames)
{
var returnData = new RestItemData();
foreach (string fieldName in fieldNames ?? GetDefaultFieldNames())
{
object value = GetValue(fieldName);
returnData.Add(fieldName, value);
}
return(Task.FromResult(returnData));
}
public async Task <RestItemData> GetDataAsync(IEnumerable <string> fieldNames)
{
var fieldAuth = new FieldAuthChecker <TItem>(_context.Fields, _context.AuthorizationChecker, _item);
IEnumerable <string> fields = fieldAuth.GetOrEnsureFields(fieldNames, 0);
var selector = new QueryableFieldSelector <TItem>(_context.Fields, fields);
var loadedObjects = await selector.SelectFieldsOnlyAsync(_item.Query, _context.Repository.ForEachAsync);
RestItemData loadedObject = ItemQueryHelper.SingleOrThrow(loadedObjects);
return(loadedObject);
}
private object ConvertObject(JObject jObject)
{
var obj = new RestItemData();
IDictionary <string, object> dictionary = obj;
foreach (JProperty property in jObject.Properties())
{
string key = ConvertRequestedToCoded(property.Name);
dictionary.Add(key, property.Value.ToObject <object>()); // TODO support sub collections and sub items
}
return(obj);
}
private IEnumerable <FilterInstruction> GetFilterInstructions(RestItemData itemData)
{
foreach (string fieldName in itemData.Keys)
{
IItemLocator <TNav> locator = _subContext.Fields.GetLocator(fieldName);
if (locator == null)
{
continue;
}
string findValue = itemData[fieldName].ToString(); // todo currently converts from int only to be parsed back later
yield return(new FilterInstruction(fieldName, FilterComparisonOperator.Equals, findValue));
}
}
public async Task ItemEndpoint()
{
IRestEndpoint endpoint = _navigator.GetEndpointFromPath("artists/123");
ItemBody itemBody = (ItemBody)(await endpoint.GetAsync(null));
RestItemData itemData = itemBody.Item;
Assert.Equal("ID", itemData.Keys.First());
int firstId = (int)itemData["ID"];
Assert.True(firstId > 0);
}
private RestItemData GetOutputData(RestResourceInfo info)
{
var data = new RestItemData();
data.Add("Name", _pathNameSwitcher(info.Name)); // keys switch naming conventions in .Formatting, but values don't
data.Add("Type", info.Type.ToString().SeparateCamelCase("_", true)); // TODO naming convention? and error types too
if (!string.IsNullOrEmpty(info.Description))
{
data.Add("Description", info.Description);
}
return(data);
}
private void TestGeneratorForResource(IResponseModifier modifier, bool wrapsObject)
{
var aggBuilder = new AggregateResponseModifier(new MainBodyResponseModifier(), modifier);
var response = new Response(null);
RestItemData itemData = CreateAndAddResponseContent(aggBuilder, response);
var generatedItemData = new RestItemData(response.GetFullBody());
if (wrapsObject)
{
generatedItemData = new RestItemData(generatedItemData[ResponseUtility.ResourceKey]);
}
Assert.Equal(itemData, generatedItemData, new ItemDataComparer());
}
public static T As <T>(this RestItemData itemData)
where T : class, new()
{
// TODO: possibly deffered RestItemData Stream so we can use newtonsoft directly?
var item = new T();
Type type = typeof(T);
foreach (KeyValuePair <string, object> pair in itemData)
{
PropertyInfo property = type.GetProperty(pair.Key, PROPERTY_BINDING_FLAGS);
object convertedValue = Convert.ChangeType(pair.Value, property.PropertyType);
property.SetValue(item, convertedValue);
}
return(item);
}
public async Task <CreatedItemAcknowledgment> AddAsync(RestItemData itemData)
{
using (HttpClient client = HttpClientCreator.Create())
{
HttpResponseMessage response = await client.PostAsync(Path, Serializer.SerializeItemToContent(itemData));
Acknowledgment acknowledgment = await EnsureSuccessAsync(response);
var created = acknowledgment as CreatedItemAcknowledgment;
if (created == null)
{
throw new InvalidOperationException("REST API did not return status code 201 after creating an item.");
}
return(created);
}
}
public async Task SetValueAsync(IDeferredItem <TItem> item, object deserializedValue, IDataTransaction dataTransaction)
{
IEngineRepository <TNav> navRepository = new NavigationItemRepository <TItem, TNav>(item, _navTools.NavExpression, _navTools.Setter);
var itemData = new RestItemData(deserializedValue);
var navLocatorCreator = new NavigationItemLocatorCreator <TNav>(_subContext);
DeferredItemBase <TNav> deferredItem = await navLocatorCreator.LocateOrCreateItemAsync(navRepository, itemData, item.LoadAsync);
try
{
IDataTransaction transaction = new VoidTransaction(); // we commit the transaction in the parent. TODO optional save-as-you-go ?
var navContext = new FullEngineContext <TNav>(transaction, navRepository, _subContext);
var navEngineItem = new EngineRestItem <TNav>(navContext, deferredItem);
Acknowledgment acknowledgment = await navEngineItem.EditAsync(itemData);
}
catch (RestApiException ex)
{
throw new SubWriterException(ex, item);
}
}
public async Task <CreatedItemAcknowledgment> AddAsync(RestItemData itemData)
{
if (!_context.AuthorizationChecker.CanAddItem())
{
throw new NotAuthorizedForItemException(AuthorizableVerb.Add);
}
_context.Transaction.StartTransaction();
await _context.Repository.InitializeAsync();
TItem newItem = _context.Repository.CreateAndAttachItem();
var setter = new QueryableFieldSetter <TItem>(_context);
await setter.SetMappedValuesAsync(new PostedNewItem <TItem>(newItem), itemData);
await _context.Transaction.SaveChangesAsync();
object identifier = _context.Identifiers.GetInfo(null).GetValue(newItem);
return(new CreatedItemAcknowledgment(identifier));
}
public async Task <Acknowledgment> EditAsync(RestItemData itemData)
{
if (!_context.AuthorizationChecker.CanEditItem(_item))
{
throw new NotAuthorizedForItemException(AuthorizableVerb.Edit);
}
var setter = new QueryableFieldSetter <TItem>(_context);
await setter.SetMappedValuesAsync(_item, itemData);
await _item.LoadAsync();
_context.Repository.MarkUpdated(_item.LoadedItem);
await _context.Transaction.SaveChangesAsync();
if (_item.WasCreated)
{
return(new CreatedItemAcknowledgment(_item.Identifier));
}
return(new Acknowledgment());
}
public async Task SetValueAsync(IDeferredItem <TItem> item, object deserializedValue, IDataTransaction dataTransaction)
{
IEngineRepository <TNav> navRepository = new NavigationCollectionRepository <TItem, TCollection, TNav>(item, _navTools.NavExpression, _navTools.Setter);
IDataTransaction transaction = new VoidTransaction(); // we commit the transaction in the parent. TODO optional save-as-you-go ?
var navContext = new FullEngineContext <TNav>(transaction, navRepository, _subContext);
var navLocatorCreator = new NavigationItemLocatorCreator <TNav>(_subContext);
IEnumerable deserializedCollection = (IEnumerable)deserializedValue; // todo null ?
foreach (object deserializedItem in deserializedCollection)
{
var itemData = new RestItemData(deserializedItem);
DeferredItemBase <TNav> deferredItem = await navLocatorCreator.LocateOrCreateItemAsync(navRepository, itemData, item.LoadAsync);
var navEngineItem = new EngineRestItem <TNav>(navContext, deferredItem);
Acknowledgment acknowledgment = await navEngineItem.EditAsync(itemData);
}
// TODO: remove items that were not located?
}
public ItemBody(RestItemData item)
{
Item = item;
}
public async Task SetMappedValuesAsync([NotNull] IDeferredItem <TItem> deferredItem, [NotNull] RestItemData itemData)
{
foreach (KeyValuePair <string, object> kvp in itemData)
{
if (!_fieldProvider.FieldExists(kvp.Key))
{
throw new FieldNotFoundException(kvp.Key, false);
}
IFieldWriter <TItem> fieldWriter = _fieldProvider.GetWriter(kvp.Key);
if (fieldWriter == null)
{
throw new FieldOperationNotAllowedException(kvp.Key, FieldOperation.Write);
}
var namedField = new NamedField <TItem>(kvp.Key, _fieldProvider);
if (!_authChecker.CanEditField(deferredItem, namedField))
{
throw new NotAuthorizedForFieldException(AuthorizableVerb.Edit, kvp.Key);
}
await fieldWriter.SetValueAsync(deferredItem, kvp.Value, _dataTransaction);
}
}
private QueryableSingleRepository <TNav> LocateItemByFilters(IQueryable <TNav> query, RestItemData itemData)
{
IEnumerable <FilterInstruction> filterInstructions = GetFilterInstructions(itemData);
var filter = new QueryableFieldFilter <TNav>(_subContext.Fields, filterInstructions);
var itemQuery = filter.ApplyFilter(query).SingleDefferred();
return(new QueryableSingleRepository <TNav>(itemQuery));
}
/// <summary>
/// Attempts to locate the item to modify using the modification request data.
/// </summary>
internal DeferredItemBase <TNav> LocateItem(IEngineRepository <TNav> navRepository, RestItemData itemData)
{
foreach (string fieldName in itemData.Keys)
{
// TODO implicit & explicit location option e.g. { "*id": 123 }
IItemLocator <TNav> locator = _subContext.Fields.GetLocator(fieldName);
if (locator != null)
{
object findValue = itemData[fieldName];
TNav locatedItem = locator.TryLocateItem(navRepository, findValue);
if (locatedItem != null)
{
itemData.Remove(fieldName); // remove so we don't write to this value later.
return(new LoadedItem <TNav>(locatedItem));
}
}
}
return(null);
}
/// <summary>
/// Attempts to locate the item to modify using the modification request data.
/// </summary>
internal async Task <DeferredItemBase <TNav> > LocateOrCreateItemAsync(IEngineRepository <TNav> navRepository, RestItemData itemData, Func <Task> loadParentAsync)
{
var locatedItem = LocateItem(navRepository, itemData);
if (locatedItem != null)
{
return(locatedItem);
}
await loadParentAsync();
return(new CreatableItem <TNav>(navRepository));
}
public Task <Acknowledgment> EditAsync(RestItemData itemData)
{
throw new NotImplementedException();
}
public async Task <CreatedItemAcknowledgment> AddAsync(RestItemData itemData)
{
List.Add((string)itemData["value"]);
return(new CreatedItemAcknowledgment(123));
}
public Task <CreatedItemAcknowledgment> AddAsync(RestItemData itemData)
{
throw new NotImplementedException("Test collection not implemented adding.");
}
public async Task <ResourceBody> GetAsync(IRestCollectionQuery query)
{
RestItemData item = await Item.GetDataAsync(query?.SelectFields);
return(new ItemBody(item));
}
private KeyValuePair <string, object> GetIdentifiedPair(RestItemData item)
{
return(new KeyValuePair <string, object>(item[_identifierName].ToString(), item));
}
