public function store(Request $request, Task $task)
 {
     $task->addNote(new Note($request->all()));
     $task->setUpdatedAt(Carbon::now()->toDateTimeString());
     $task->save();
     return back();
 }

 /**
  * Destroy the given task.
  *
  * @param  Request  $request
  * @param  Task  $task
  * @return Response
  */
 public function destroy(Request $request, Task $task)
 {
     if (\Auth::id() == $task->user_id) {
         $task->delete();
     }
     return redirect('/tasks');
 }

 /**
  * checks each step of the path if it was completed (based on its timestamp).
  * also calls the findCrossingPath method to (surprise!) find the paths crossing the current path
  *
  * @param Task $task
  */
 public static function pathProgress(Task $task)
 {
     if ($task->path->isEmpty()) {
         $task->army->update(['task_id' => 0, 'path_id' => 0]);
         $task->delete();
         return;
     }
     $path = $task->path;
     self::processFoodConsumption($path);
     $finished = null;
     $path->filter(function ($item) use(&$finished) {
         if ($item->finished_at <= Carbon::now()) {
             // if the step is finished
             self::findCrossingPath($item);
             $finished = $item;
             $item->delete();
         }
     });
     // now $finished is the last element of the path.
     // $finished has the hex where the army is
     if ($finished != null) {
         $army = $task->army;
         $army->currentHex->update(['army_id' => 0]);
         $army->update(['current_hex_id' => $finished->hex_id]);
         $finished->hex->update(['army_id' => $army->id]);
     }
     if ($path->isEmpty()) {
         $task->army->update(['task_id' => 0, 'path_id' => 0]);
         $task->delete();
     }
 }

 /**
  * Create a new task` for the given user and data.
  *
  * @param  \Illuminate\Contracts\Auth\Authenticatable  $user
  * @param  array  $data
  * @return \App\Task
  */
 public function create($user, array $data)
 {
     $task = new Task($data);
     $task->user_id = $user->id;
     $task->save();
     return $task;
 }

 /**
  * Store a newly created resource in storage.
  *
  * @param  \Illuminate\Http\Request  $request
  * @return \Illuminate\Http\Response
  */
 public function store(Request $request)
 {
     $task = new Task();
     $task->name = $request->name;
     $task->user_id = $request->user_id;
     $task->save();
 }

 public function getDelete(Task $task)
 {
     if ($task->user_id == Auth::user()->id) {
         //delete task als de juiste user is ingelogd
         $task->delete();
     }
     return Redirect::route('home');
 }

 public function newtask(Request $request)
 {
     $this->validate($request, ['name' => 'required|max:10']);
     $task = new Task();
     $task->name = $request->name;
     $task->save();
     return redirect('tasks');
 }

 public static function createTask($input)
 {
     $task = new Task();
     $task->title = $input['title'];
     $task->complete = $input['complete'];
     $task->save();
     return $task;
 }

 public function save(Task $task, $members = null)
 {
     $task->save();
     /* Insert Task Members to Pivot Table */
     if ($members) {
         $task->syncMembers($members);
     }
     return true;
 }

 function testSetLabelToTask()
 {
     $label = factory(\App\ProjectLabel::class)->make(['name' => "foo"]);
     $this->project->labels()->save($label);
     $this->task->label()->associate($label)->save();
     $this->assertEquals('foo', $this->task->label->name);
     $this->assertEquals(2, $this->task->activity->count());
     $this->assertEquals($label->id, $this->task->activity->get(1)->note);
 }

 public function seedTasks($faker)
 {
     foreach (range(0, 100) as $number) {
         $task = new Task();
         $task->name = $faker->sentence;
         $task->done = $faker->boolean;
         $task->priority = $faker->randomDigit;
         $task->save();
     }
 }

 /**
  * @param Faker $faker
  */
 private function seedTasks($faker)
 {
     foreach (range(0, 100) as $item) {
         $task = new Task();
         $task->name = $faker->sentence();
         $task->done = $faker->boolean();
         $task->priority = $faker->randomDigit();
         $task->save();
     }
 }

 /**
  * Function for adding new user to database
  * @param Request $request [http request with data]
  * @return id [id of the task added]
  */
 public function add(Request $request)
 {
     if (Auth::check()) {
         $user_id = Auth::user()->id;
         $task = new Task();
         $task->task_name = $request->task_name;
         $task->user_id = $user_id;
         $task->save();
         return $task->id;
     }
 }

 /**
  * Update the specified resource in storage.
  *
  * @param  int  $id
  * @return Response
  */
 public function update($id, Request $request)
 {
     $this->validate($request, ['title' => 'required', 'description' => 'required']);
     $input = $request->all();
     $mTask = new Task();
     $task = $mTask->getTaskById($id);
     //        dd($task->toArray());
     $task->saveTask($id, $input);
     //        Session::flash('flash_message', 'Task successfully added!');
     return redirect()->back()->with('flash_message', 'Task successfully added!');
 }

 /**
  * @param Task $task
  */
 public static function finishTask(Task $task)
 {
     switch ($task->type) {
         case 1:
             // create worker
             $task->building->city->human_resources->workers += 1;
             $task->building->city->human_resources->save();
             $task->delete();
             break;
         case 2:
             // create settler
             $task->building->city->human_resources->settlers += 1;
             $task->building->city->human_resources->save();
             $task->delete();
             break;
         case 3:
             // create a general
             if ($task->building->city->hex->army_id == 0) {
                 $army = Army::create(['user_id' => $task->building->city->owner, 'current_hex_id' => $task->building->city->hex->id]);
                 $task->building->city->hex->army_id = $army->id;
                 $task->building->city->hex->save();
             }
             if ($task->building->city->hex->army->general) {
                 break;
             }
             $task->building->city->hex->army->update(['general' => true]);
             $task->delete();
             break;
         case 11:
             // create unit
         // create unit
         case 12:
         case 13:
         case 14:
         case 15:
         case 16:
         case 17:
             if ($task->building->city->hex->army_id == 0) {
                 $army = Army::create(['user_id' => $task->building->city->owner, 'current_hex_id' => $task->building->city->hex->id]);
                 $task->building->city->hex->army_id = $army->id;
                 $task->building->city->hex->save();
             }
             $unit_type = 'unit' . ($task->type - 10);
             $task->building->city->hex->army->{$unit_type} += 1;
             $task->building->city->hex->army->save();
             $task->delete();
             break;
         case 20:
             // move army
             ArmyController::pathProgress($task);
             break;
     }
 }

 public function post(Request $request)
 {
     //echo "post";
     $validator = Validator::make($request->all(), ['name' => 'required|max:255']);
     if ($validator->fails()) {
         return redirect('/')->withInput()->withErrors($validator);
     }
     $task = new Task();
     $task->name = $request->name;
     $task->save();
     //print_r($request->name);
     return redirect('/');
 }

 public function update($taskID, TaskRequest $request)
 {
     $task = Task::findOrNew($taskID);
     $task->taskName = $request->taskName;
     $task->save();
     return view('edit', ['task' => $task]);
 }

 public function destroy($id)
 {
     $task = Task::findOrFail($id);
     $task->delete();
     \Session::flash('flash_message', 'Tarea borrada');
     return redirect()->route('tasks.index');
 }

 public function destroy($id)
 {
     $response = Task::find($id)->delete();
     if ($response) {
         return redirect('/');
     }
 }

 public function markComplete($taskId)
 {
     $task = Task::find($taskId);
     $task->completed = true;
     $task->save();
     return redirect()->route('tasks');
 }