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)); }