/**
*
* @param Unit $unit
* @return \Illuminate\Http\Response
* @throws \Exception
*/
public function destroy(Unit $unit)
{
try {
$unit->delete();
return $this->responseNoContent();
} catch (\Exception $e) {
//Integrity constraint violation
if ($e->getCode() === '23000') {
$message = 'Unit could not be deleted. It is in use.';
} else {
$message = 'There was an error';
}
return response(['error' => $message, 'status' => Response::HTTP_BAD_REQUEST], Response::HTTP_BAD_REQUEST);
}
}
/**
* Entry can be either just a food, or part of a recipe.
* When part of a recipe, the store method inserts just one food at a time,
* so that the store method is RESTful.
* So lots of ajax requests will be made to insert
* all the entries for a whole recipe.
* POST /api/menuEntries
* @param Request $request
* @return Response
*/
public function store(Request $request)
{
$entry = new Entry($request->only(['date', 'quantity']));
$entry->user()->associate(Auth::user());
$entry->food()->associate(Food::find($request->get('food_id')));
if ($request->get('recipe_id')) {
$entry->recipe()->associate(Recipe::find($request->get('recipe_id')));
}
$entry->unit()->associate(Unit::find($request->get('unit_id')));
$entry->save();
$entry = $this->transform($this->createItem($entry, new MenuEntryTransformer()))['data'];
return response($entry, Response::HTTP_CREATED);
}
/**
* @test
* @return void
*/
public function it_cannot_delete_an_exercise_unit_that_is_in_use()
{
DB::beginTransaction();
$this->logInUser();
$unit = Unit::where('for', 'exercise')->first();
$response = $this->call('DELETE', '/api/exerciseUnits/' . $unit->id);
$content = json_decode($response->getContent(), true);
// dd($content);
$this->assertArrayHasKey('error', $content);
$this->assertEquals('Unit could not be deleted. It is in use.', $content['error']);
$this->assertEquals(400, $response->getStatusCode());
DB::rollBack();
}
/**
*
*/
private function createRecipes()
{
foreach (Config::get('recipes') as $tempRecipe) {
$recipe = new Recipe(['name' => $tempRecipe['name']]);
$recipe->user()->associate($this->user);
$recipe->save();
foreach ($tempRecipe['ingredients'] as $ingredient) {
$food = Food::where('user_id', $this->user->id)->where('name', $ingredient['food'])->first();
$recipe->foods()->attach([$food->id => ['unit_id' => Unit::where('user_id', $this->user->id)->where('name', $ingredient['unit'])->first()->id, 'quantity' => $ingredient['quantity'], 'description' => $ingredient['description']]]);
}
foreach ($tempRecipe['tags'] as $tempTag) {
$tag = Tag::where('user_id', $this->user->id)->where('name', $tempTag)->first();
$recipe->tags()->attach([$tag->id => ['taggable_type' => 'recipe']]);
}
$recipe->save();
}
}
public function run()
{
Exercise::truncate();
$this->faker = Faker::create();
$pushups = [['name' => 'kneeling pushups', 'defaultQuantity' => 20, 'description' => '', 'priority' => 2, 'frequency' => 7], ['name' => 'pushups', 'defaultQuantity' => 10, 'description' => 'hands shoulder width', 'priority' => 1], ['name' => 'one-arm pushups', 'defaultQuantity' => 2, 'description' => 'free hand behind back', 'priority' => 1]];
$squats = [['name' => 'assisted squats', 'defaultQuantity' => 50, 'description' => 'hold onto something', 'priority' => 3, 'frequency' => 3], ['name' => 'squats', 'defaultQuantity' => 30, 'description' => 'feet shoulder width', 'priority' => 2], ['name' => 'one-legged-squats', 'defaultQuantity' => 5, 'description' => '', 'priority' => 1]];
$gymnasticRings = [['name' => 'back lever', 'defaultQuantity' => 30, 'description' => '', 'priority' => 1, 'frequency' => 4]];
$flexibility = [['name' => 'hamstrings', 'defaultQuantity' => 20, 'description' => '', 'priority' => 2, 'stretch' => 1, 'frequency' => 7], ['name' => 'calves', 'defaultQuantity' => 10, 'description' => 'great stretch', 'priority' => 1, 'stretch' => 1]];
$users = User::all();
foreach ($users as $user) {
$this->user = $user;
$exercise_unit_ids = Unit::where('user_id', $this->user->id)->where('for', 'exercise')->lists('id')->all();
$this->insertExercisesInSeries($pushups, Unit::find($exercise_unit_ids[0]), Series::where('user_id', $this->user->id)->where('name', 'pushup')->first());
$this->insertExercisesInSeries($squats, Unit::find($exercise_unit_ids[1]), Series::where('user_id', $this->user->id)->where('name', 'squat')->first());
$this->insertExercisesInSeries($gymnasticRings, Unit::find($exercise_unit_ids[1]), Series::where('user_id', $this->user->id)->where('name', 'gymnastic rings')->first());
$this->insertExercisesInSeries($flexibility, Unit::find($exercise_unit_ids[1]), Series::where('user_id', $this->user->id)->where('name', 'flexibility')->first());
}
}
/**
* Insert an exercise entry.
* It can be an exercise set.
* @param Request $request
* @return \Illuminate\Http\Response
*/
public function store(Request $request)
{
$exercise = Exercise::find($request->get('exercise_id'));
if ($request->get('exerciseSet')) {
// We are inserting an exercise set
$quantity = $exercise->default_quantity;
$unit = Unit::find($exercise->default_unit_id);
} else {
$quantity = $request->get('quantity');
$unit = Unit::find($request->get('unit_id'));
}
$entry = new Entry(['date' => $request->get('date'), 'quantity' => $quantity]);
$entry->user()->associate(Auth::user());
$entry->exercise()->associate($exercise);
$entry->unit()->associate($unit);
$entry->save();
//Return the entries for the day
$entries = transform(createCollection($this->exerciseEntriesRepository->getEntriesForTheDay($request->get('date')), new ExerciseEntryTransformer()))['data'];
return response($entries, Response::HTTP_CREATED);
}
/**
* @test
*/
public function it_can_add_an_ingredient_to_a_recipe()
{
DB::beginTransaction();
$this->logInUser();
$recipe = Recipe::forCurrentUser()->first();
$food = Food::forCurrentUser()->offset(2)->first();
$unit = Unit::forCurrentUser()->where('for', 'food')->offset(2)->first();
$data = ['addIngredient' => true, 'food_id' => $food->id, 'unit_id' => $unit->id, 'quantity' => 9, 'description' => 'blah blah'];
$foodCount = count($recipe->foods);
$response = $this->call('PUT', '/api/recipes/' . $recipe->id, $data);
$content = json_decode($response->getContent(), true);
// dd($content);
$this->seeInDatabase('food_recipe', ['food_id' => $food->id, 'unit_id' => $unit->id, 'quantity' => 9, 'description' => 'blah blah']);
$this->assertCount($foodCount + 1, $recipe->foods()->get());
$this->checkRecipeKeysExist($content);
$this->checkIngredientKeysExist($content['ingredients']['data'][0]);
$this->assertCount($foodCount + 1, $content['ingredients']['data']);
$this->assertEquals(200, $response->getStatusCode());
DB::rollBack();
}
public function run()
{
/**
* exercise units
*/
Unit::truncate();
$users = User::all();
foreach ($users as $user) {
Unit::create(['name' => 'reps', 'for' => 'exercise', 'user_id' => $user->id]);
Unit::create(['name' => 'minutes', 'for' => 'exercise', 'user_id' => $user->id]);
/**
* food units
*/
Unit::create(['name' => 'small', 'for' => 'food', 'user_id' => $user->id]);
Unit::create(['name' => 'medium', 'for' => 'food', 'user_id' => $user->id]);
Unit::create(['name' => 'large', 'for' => 'food', 'user_id' => $user->id]);
Unit::create(['name' => 'grams', 'for' => 'food', 'user_id' => $user->id]);
Unit::create(['name' => 'ounces', 'for' => 'food', 'user_id' => $user->id]);
Unit::create(['name' => 'kgs', 'for' => 'food', 'user_id' => $user->id]);
Unit::create(['name' => 'pounds', 'for' => 'food', 'user_id' => $user->id]);
Unit::create(['name' => 'bunch', 'for' => 'food', 'user_id' => $user->id]);
}
}
/**
*
* @param Request $request
* @param Exercise $exercise
* @return mixed
*/
public function update(Request $request, Exercise $exercise)
{
// Create an array with the new fields merged
$data = array_compare($exercise->toArray(), $request->only(['name', 'step_number', 'default_quantity', 'description', 'target', 'priority', 'frequency']));
$exercise->update($data);
if ($request->has('stretch')) {
$exercise->stretch = $request->get('stretch');
$exercise->save();
}
if ($request->has('series_id')) {
$series = Series::findOrFail($request->get('series_id'));
$exercise->series()->associate($series);
$exercise->save();
}
if ($request->has('program_id')) {
$program = ExerciseProgram::findOrFail($request->get('program_id'));
$exercise->program()->associate($program);
$exercise->save();
}
if ($request->has('default_unit_id')) {
$unit = Unit::where('for', 'exercise')->findOrFail($request->get('default_unit_id'));
$exercise->defaultUnit()->associate($unit);
$exercise->save();
}
return $this->responseOkWithTransformer($exercise, new ExerciseTransformer());
}
/**
* @test
* @return void
*/
public function it_can_delete_an_exercise_entry()
{
$this->logInUser();
$date = Carbon::today()->format('Y-m-d');
$entry = new Entry(['date' => $date, 'quantity' => 501]);
$entry->user()->associate($this->user);
$entry->exercise()->associate(Exercise::find(1));
$entry->unit()->associate(Unit::find(1));
$entry->save();
$this->seeInDatabase('exercise_entries', ['date' => $date, 'exercise_id' => 1, 'quantity' => 501, 'exercise_unit_id' => 1]);
$response = $this->call('DELETE', '/api/exerciseEntries/' . $entry->id);
$this->assertEquals(204, $response->getStatusCode());
$this->missingFromDatabase('exercise_entries', ['date' => $date, 'exercise_id' => 1, 'quantity' => 501, 'exercise_unit_id' => 1]);
$response = $this->call('DELETE', '/api/exerciseEntries/' . $entry->id);
$this->assertEquals(404, $response->getStatusCode());
}
/**
*
* @param Food $food
* @param $tempFood
*/
private function attachDefaultUnit(Food $food, $tempFood)
{
$defaultUnit = Unit::where('user_id', $this->user->id)->where('name', $tempFood['defaultUnit'])->first();
$food->defaultUnit()->associate($defaultUnit);
}
/**
*
* @param $name
* @return Unit
*/
public function findOrInsertUnitIfNotExists($name)
{
$unit = Unit::forCurrentUser()->where('name', $name)->first();
if (!$unit) {
$unit = $this->unitsRepository->insert($name);
}
return $unit;
}
/**
*
* @param Entry $entry
* @param $index
*/
private function attachUnit(Entry $entry, $index)
{
$unit_ids = collect($entry->food->units)->lists('id')->all();
$entry->unit()->associate(Unit::find($unit_ids[$index]));
}
/**
* @test
* @return void
*/
public function it_can_update_a_food()
{
DB::beginTransaction();
$this->logInUser();
$food = Food::forCurrentUser()->first();
$defaultUnit = Unit::forCurrentUser()->where('for', 'food')->where('id', '!=', $food->defaultUnit->id)->first();
$unitIds = Unit::forCurrentUser()->where('for', 'food')->limit(2)->offset(1)->lists('id')->all();
$response = $this->call('PUT', '/api/foods/' . $food->id, ['name' => 'numbat', 'default_unit_id' => $defaultUnit->id, 'unit_ids' => $unitIds]);
$content = json_decode($response->getContent(), true);
// dd($content);
$this->checkFoodKeysExist($content);
$this->assertEquals('numbat', $content['name']);
$this->assertEquals($unitIds, $content['unitIds']);
$this->assertEquals($defaultUnit->id, $content['defaultUnit']['data']['id']);
$this->assertEquals(200, $response->getStatusCode());
DB::rollBack();
}
/**
*
* @param $ingredient
* @return \League\Fractal\Resource\Collection
*/
public function includeUnit($ingredient)
{
return $this->item(Unit::find($ingredient->unit_id), new UnitTransformer());
}
/**
* Create the entries for the same exercise but with different units
* for today, so that I can test out the getSpecificExerciseEntries
* for a day where the exercise is entered with different units
*/
private function createEntriesForToday()
{
$exercise = Exercise::where('user_id', $this->user->id)->first();
$date = Carbon::today();
$this->createEntry(5, $exercise, Unit::find($this->unit_ids[0]), $date);
$this->createEntry(5, $exercise, Unit::find($this->unit_ids[0]), $date);
$this->createEntry(10, $exercise, Unit::find($this->unit_ids[1]), $date);
}
/**
* UPDATE /api/foods/{foods}
* @param Request $request
* @param Food $food
* @return Response
*/
public function update(Request $request, Food $food)
{
if ($request->get('updatingCalories')) {
//We are updating the calories for one of the food's units
$food->units()->updateExistingPivot($request->get('unit_id'), ['calories' => $request->get('calories')]);
} else {
// Create an array with the new fields merged
$data = array_compare($food->toArray(), $request->only(['name']));
$food->update($data);
if ($request->has('default_unit_id')) {
$food->defaultUnit()->associate(Unit::findOrFail($request->get('default_unit_id')));
$food->save();
}
if ($request->has('unit_ids')) {
$food->units()->sync($request->get('unit_ids'));
}
}
$food = $this->transform($this->createItem($food, new FoodTransformer()))['data'];
return response($food, Response::HTTP_OK);
}
/**
* Define your route model bindings, pattern filters, etc.
*
* @param \Illuminate\Routing\Router $router
* @return void
*/
public function boot(Router $router)
{
parent::boot($router);
Route::bind('exercises', function ($id) {
return Exercise::forCurrentUser()->findOrFail($id);
});
Route::bind('exerciseEntries', function ($id) {
return ExerciseEntry::forCurrentUser()->findOrFail($id);
});
Route::bind('menuEntries', function ($id) {
return MenuEntry::forCurrentUser()->findOrFail($id);
});
Route::bind('exerciseSeries', function ($id) {
return ExerciseSeries::forCurrentUser()->findOrFail($id);
});
Route::bind('foods', function ($id) {
return Food::forCurrentUser()->findOrFail($id);
});
Route::bind('recipes', function ($id) {
return Recipe::forCurrentUser()->findOrFail($id);
});
Route::bind('exerciseTags', function ($id) {
return Tag::forCurrentUser()->where('for', 'exercise')->findOrFail($id);
});
Route::bind('recipeTags', function ($id) {
return Tag::forCurrentUser()->where('for', 'recipe')->findOrFail($id);
});
Route::bind('foodUnits', function ($id) {
return Unit::forCurrentUser()->where('for', 'food')->findOrFail($id);
});
Route::bind('exerciseUnits', function ($id) {
return Unit::forCurrentUser()->where('for', 'exercise')->findOrFail($id);
});
Route::bind('timers', function ($id) {
return Timer::forCurrentUser()->findOrFail($id);
});
Route::bind('activities', function ($id) {
return Activity::forCurrentUser()->findOrFail($id);
});
Route::bind('weights', function ($idOrDate) {
if (strrpos($idOrDate, '-')) {
//parameter is the date of the entry
$weight = Weight::forCurrentUser()->where('date', $idOrDate)->first();
} else {
//parameter is the id of the entry
$weight = Weight::forCurrentUser()->findOrFail($idOrDate);
}
return $weight;
});
/**
* $parameter is either the id or the date
*/
Route::bind('journal', function ($parameter) {
/**
* @VP:
* Is there a better way to check if the $parameter is an
* id or a date? When I tried using Carbon to create an object from
* the parameter, it threw an exception when the $parameter was the id,
* whereas I just wanted a boolean.
*/
if (strrpos($parameter, '-')) {
//$parameter is the date of the entry
$journal = Journal::forCurrentUser()->where('date', $parameter)->first();
} else {
//$parameter is the id of the entry
$journal = Journal::forCurrentUser()->findOrFail($parameter);
}
return $journal;
});
}
/**
*
* @return mixed
*/
public function getExerciseUnits()
{
return Unit::forCurrentUser()->where('for', 'exercise')->orderBy('name', 'asc')->get();
}
