//[AuthorizeOwnerIntId(typeof(WorkoutOfmRepository))]
public async Task <IActionResult> GetById(int id, WorkoutOfmResourceParameters workoutOfmResourceParameters)
{
var stringGuid = User.Claims.FirstOrDefault(c => c.Type == "sub")?.Value;
if (String.IsNullOrWhiteSpace(stringGuid))
{
return(Unauthorized());
}
var ownerGuid = new Guid(stringGuid);
var ofmForGetQueryResult = await _asyncOfmRepository.GetById(id, workoutOfmResourceParameters, ownerGuid);
if (!_controllerGuardClause.ValidateGetById(ofmForGetQueryResult, id, out ObjectResult objectResult))
{
return(objectResult);
}
var expandable = ofmForGetQueryResult.ReturnedTOfmForGet.ToExpandableOfm();
var shapedExpandable = expandable.Shape(workoutOfmResourceParameters.Fields);
if (_incomingHeaders.IncludeHateoas)
{
shapedExpandable.Add("links", _hateoasLinkFactory.CreateLinksForOfmForGet(id, workoutOfmResourceParameters.Fields).ToList());
}
return(Ok(shapedExpandable));
}
public async Task ReturnSuccessfulOfmQueryResult_UsingGetSingleWithResourceParameters()
{
await Task.Run(async() =>
{
using (var testAppConfiguration = new AppConfigurationMock(File.ReadAllText(Path.GetDirectoryName(typeof(Startup).GetTypeInfo().Assembly.Location) + "\\appsettings.json")))
{
// ARRANGE
var httpContextAccessorMock = new Mock <IHttpContextAccessor>();
var httpRequestHandlerMock = new Mock <IHttpRequestExecuter>();
var workoutApiModelRepository = new WorkoutApiModelRepository(
testAppConfiguration.Instance, httpContextAccessorMock.Object, httpRequestHandlerMock.Object);
var returnedWorkoutOfmForGet = new WorkoutOfmForGet()
{
Id = 1,
Name = "MockWorkoutName"
};
var uri = new Uri(testAppConfiguration.Instance.GetValue <string>("FittifyApiBaseUrl") + "api/workouts/1?IncludeMapsExerciseWorkout=1");
var httpResponse = new HttpResponseMessage();
var resourceParameters = new WorkoutOfmResourceParameters()
{
IncludeMapsExerciseWorkout = "1"
};
httpResponse.Content = new StringContent(JsonConvert.SerializeObject(returnedWorkoutOfmForGet));
httpResponse.StatusCode = HttpStatusCode.OK;
httpRequestHandlerMock.Setup(s => s.GetSingle(uri, testAppConfiguration.Instance, httpContextAccessorMock.Object)).ReturnsAsync(httpResponse);
// ACT
var ofmQueryResult = await workoutApiModelRepository.GetSingle(1, resourceParameters);
// Assert
var actualOfmQueryResult = JsonConvert.SerializeObject(ofmQueryResult, new JsonSerializerSettings()
{
Formatting = Newtonsoft.Json.Formatting.Indented
}).MinifyJson().PrettifyJson();
var expectedOfmQueryResult =
@"
{
""OfmForGet"": {
""Id"": 1,
""RangeOfExerciseIds"": null,
""MapsExerciseWorkout"": null,
""RangeOfWorkoutHistoryIds"": null,
""Name"": ""MockWorkoutName""
},
""HttpStatusCode"": 200,
""HttpResponseHeaders"": [],
""ErrorMessagesPresented"": null
}
".MinifyJson().PrettifyJson();
Assert.AreEqual(actualOfmQueryResult, expectedOfmQueryResult);
}
});
}
public async Task NotReturnSingleOfmGetById_WhenQueriedEntityFieldsAreErroneous()
{
// Arrange
var asyncDataCrudMock = new Mock <IAsyncCrud <Workout, int, WorkoutResourceParameters> >();
asyncDataCrudMock
.Setup(s => s.GetById(It.IsAny <int>())).Returns(Task.FromResult(new Workout()
{
Id = 1
}));
var workoutOfmRepository = new WorkoutOfmRepository(asyncDataCrudMock.Object, new PropertyMappingService(), new TypeHelperService());
// Act
var workoutOfmResourceParameters = new WorkoutOfmResourceParameters()
{
Fields = "ThisFieldDoesntExistOnWorkout"
};
var workoutOfmResult = await workoutOfmRepository.GetById(1, workoutOfmResourceParameters, _ownerGuid);
// Assert
var actualOfmResult = JsonConvert.SerializeObject(workoutOfmResult,
new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore, Formatting = Formatting.Indented
});
var expectedOfmResult = JsonConvert.SerializeObject(
new OfmForGetQueryResult <WorkoutOfmForGet>()
{
ReturnedTOfmForGet = null,
ErrorMessages = new List <string>()
{
"A property named 'ThisFieldDoesntExistOnWorkout' does not exist"
}
},
new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore, Formatting = Formatting.Indented
});
Assert.AreEqual(expectedOfmResult, actualOfmResult);
}
public async Task <OfmForGetQueryResult <WorkoutOfmForGet> > GetById(int id, WorkoutOfmResourceParameters resourceParameters, Guid ownerGuid)
{
var ofmForGetResult = new OfmForGetQueryResult <WorkoutOfmForGet>();
ofmForGetResult = await AsyncGetOfmGuardClause.ValidateGetById(ofmForGetResult, resourceParameters.Fields); // Todo: Validate additional *Include* query parameters
if (ofmForGetResult.ErrorMessages.Count > 0)
{
return(ofmForGetResult);
}
var workoutLinqToEntity = Repo.LinqToEntityQueryable();
workoutLinqToEntity = workoutLinqToEntity
.Include(i => i.MapExerciseWorkout)
.Include(i => i.WorkoutHistories);
if (resourceParameters.IncludeMapsExerciseWorkout.ToBool())
{
workoutLinqToEntity =
workoutLinqToEntity
.Include(i => i.MapExerciseWorkout)
.ThenInclude(i => i.Exercise);
}
var workout = workoutLinqToEntity.FirstOrDefault(f => f.Id == id && f.OwnerGuid == ownerGuid);
if (workout == null)
{
return(ofmForGetResult);
}
ofmForGetResult.ReturnedTOfmForGet = Mapper.Map <Workout, WorkoutOfmForGet>(workout);
if (resourceParameters.IncludeMapsExerciseWorkout.ToBool() && workout.MapExerciseWorkout.Count() > 0)
{
ofmForGetResult.ReturnedTOfmForGet.MapsExerciseWorkout = Mapper.Map <List <MapExerciseWorkoutOfmForGet> >(workout.MapExerciseWorkout.ToList());
}
return(ofmForGetResult);
}
public async Task <IActionResult> AssociatedExercises(int workoutId)
{
var workoutResourceParameters = new WorkoutOfmResourceParameters()
{
IncludeMapsExerciseWorkout = "1"
};
var queryResult = await _workoutViewModelRepository.GetById(workoutId, workoutResourceParameters);
if (queryResult.HttpStatusCode == HttpStatusCode.Unauthorized ||
queryResult.HttpStatusCode == HttpStatusCode.Forbidden)
{
return(RedirectToAction("AccessDenied", "Authorization"));
}
WorkoutViewModel workoutViewModel = null;
if ((int)queryResult.HttpStatusCode == 200)
{
workoutViewModel = queryResult.ViewModel;
}
return(View(workoutViewModel));
}
