public function testPostRound()
{
$user1 = factory(App\Models\User::class)->create();
$user2 = factory(App\Models\User::class)->create();
// create two open battles
$battle1 = new OpenBattle();
$battle1->rapper1_id = $user1->id;
$battle1->rapper2_id = $user2->id;
$battle1->phase = 1;
$battle1->beat1_id = 1;
$battle1->rapper1_round1 = "/path/to/rapper1_round1";
$battle1->rapper2_round2 = "/path/to/rapper2_round2";
$battle1->beat2_id = 2;
$battle1->rapper2_round1 = "/path/to/rapper2_round1";
$battle1->rapper1_round2 = "/path/to/rapper1_round2";
$battle1->save();
$this->post('/open-battle/' . $battle1->id . '/round', ['beat_id' => 2, 'video' => "abc.mp4"]);
// TODO: check if OpenBattle changed, video expects an actual video file, not sure if there is a way to fake one
$this->markTestIncomplete();
}
public function scopeOpen($query)
{
$start = Carbon::parse($this->phase_start);
$startMinPhase1 = Carbon::now()->subHours(config('rap-battle.phase1time', 24));
$startMinPhase2 = Carbon::now()->subHours(config('rap-battle.phase2time', 24));
$query1 = $query;
$query2 = clone $query;
$ids1 = $query1->where('phase', 1)->where('phase_start', '>=', $startMinPhase1->toDateTimeString())->lists('id')->toArray();
$ids2 = $query2->where('phase', 2)->where('phase_start', '>=', $startMinPhase2->toDateTimeString())->lists('id')->toArray();
return OpenBattle::whereIn('id', array_merge($ids1, $ids2));
}
public function postRound(Request $request, $id)
{
$this->validate($request, ['beat_id' => 'required|integer', 'video' => 'required|mimes:mp4,mpg,3gp,h264,ogv,mov,webm,flv,wmv,mkv']);
// get battle and user instances
$battle = OpenBattle::findOrFail($id);
$user = $request->user();
if (!$battle->isOpen()) {
return response('Gone', 410);
}
// get rapper number
$rapperNumber = 0;
if ($user == $battle->rapper1) {
$rapperNumber = 1;
} elseif ($user == $battle->rapper2) {
$rapperNumber = 2;
} else {
return response('Unauthorized.', 401);
}
// TODO: check video file?
// Name of the column the video needs to be saved in
$videoColumn = 'rapper' . $rapperNumber . '_round' . $battle->phase;
// Name of the video
$videoName = $battle->id . '_' . $videoColumn;
$video = $request->file('video');
// Name of video on the disk
$videoFilename = $videoName . '.mp4';
// target file format: mp4
$videoFilenameTmp = $videoName;
Storage::disk('videos')->put($videoFilenameTmp, file_get_contents($video->getRealPath()));
Log::info('Uploading video', ['rapperNumber' => $rapperNumber, 'phase' => $battle->phase, 'userID' => $user->id, 'videoFilenameTmp' => $videoFilenameTmp, 'videoFilename' => $videoFilename]);
// convert video/fire events and delete temporary file
$inFilePath = Storage::disk('videos')->getAdapter()->applyPathPrefix($videoFilenameTmp);
$outFilePath = Storage::disk('videos')->getAdapter()->applyPathPrefix($videoFilename);
/*
* The event 'VideoWasUploaded' will be pushed on the queue and convert
* the uploaded video. If the conversion succeds a following event will
* be fired, in this case 'OpenBattleVideoConverted'. 'OpenBattleVideoConverted'
* writes $videoFileName to the file column $videoColumn of $battle and
* sets the beat_id. When all videos are uploaded 'OpenBattleVideoConverted
* fires another event ('OpenBattleCompleted') to concatenate the video
* files and to convert the OpenBattle to a Battle. This approach was choosen
* since these steps depend on each other. When one step fails but the
* following gets executed the OpenBattle may get 'corrupted' (eg. by
* missing video files) and the conversion to a finished Battle will fail.
*/
\Event::fire(new VideoWasUploaded($outFilePath, $inFilePath, true, new OpenBattleVideoConverted($battle, $videoFilename, $videoColumn, $rapperNumber, $request->input('beat_id'))));
}
/**
* Test for postAnswer
*/
public function testPostAnswer()
{
$user1 = factory(App\Models\User::class)->create();
$user2 = factory(App\Models\User::class)->create();
// create two battles
$br = new BattleRequest();
$br->challenger_id = $user1->id;
$br->challenged_id = $user2->id;
$br->save();
// execute postAnswer()
$this->actingAs($user1)->post('/request/' . $br->id, ['accepted' == TRUE]);
$oP = OpenBattle::find($br->challenger_id);
//checking the output
$this->assertNotNull($oP);
$this->assertEquals($user1->id, $oP->rapper1_id);
$this->assertEquals($user2->id, $oP->rapper2_id);
}
/**
* Test for getOpen
*/
public function testGetOpen()
{
$user1 = factory(App\Models\User::class)->create();
$user2 = factory(App\Models\User::class)->create();
// create two open battles
$battle1 = new OpenBattle();
$battle1->rapper1_id = $user1->id;
$battle1->rapper2_id = $user2->id;
$battle1->phase = 1;
$battle1->beat1_id = 1;
$battle1->rapper1_round1 = "/path/to/rapper1_round1";
$battle1->rapper2_round2 = "/path/to/rapper2_round2";
$battle1->beat2_id = 2;
$battle1->rapper2_round1 = "/path/to/rapper2_round1";
$battle1->rapper1_round2 = "/path/to/rapper1_round2";
$battle1->save();
$battle2 = new OpenBattle();
$battle2->rapper1_id = $user1->id;
$battle2->rapper2_id = $user2->id;
$battle2->phase = 2;
$battle2->beat1_id = 2;
$battle2->rapper1_round1 = "/path/to/rapper1_round1_b";
$battle2->rapper2_round2 = "/path/to/rapper2_round2_b";
$battle2->beat2_id = 1;
$battle2->rapper2_round1 = "/path/to/rapper2_round1_b";
$battle2->rapper1_round2 = "/path/to/rapper1_round2_b";
$battle2->save();
$this->actingAs($user1)->get('/battles/open')->seeJson(['current_page' => 1, 'data' => [['battle_id' => (string) $battle1->id, 'rapper1' => ['user_id' => (string) $user1->id, 'username' => $user1->username, 'profile_picture' => $user1->picture], 'rapper2' => ['user_id' => (string) $user2->id, 'username' => $user2->username, 'profile_picture' => $user2->picture]], ['battle_id' => (string) $battle2->id, 'rapper1' => ['user_id' => (string) $user1->id, 'username' => $user1->username, 'profile_picture' => $user1->picture], 'rapper2' => ['user_id' => (string) $user2->id, 'username' => $user2->username, 'profile_picture' => $user2->picture]]]]);
}
/**
* Test for openBattles()
*
* @return void
*/
public function testOpenBattles()
{
$user1 = factory(App\Models\User::class)->create();
$user2 = factory(App\Models\User::class)->create();
$user3 = factory(App\Models\User::class)->create();
$user4 = factory(App\Models\User::class)->create();
$battle1 = new OpenBattle();
$battle1->rapper1_id = $user1->id;
$battle1->rapper2_id = $user2->id;
$battle1->save();
$battle2 = new OpenBattle();
$battle2->rapper1_id = $user2->id;
$battle2->rapper2_id = $user3->id;
$battle2->save();
$battle3 = new OpenBattle();
$battle3->rapper1_id = $user3->id;
$battle3->rapper2_id = $user1->id;
$battle3->save();
// get open battles of user2
$battles = $user2->openBattles()->lists('id')->toArray();
$this->assertCount(2, $battles);
$this->assertContains($battle1->id, $battles);
$this->assertContains($battle2->id, $battles);
$this->assertNotContains($battle3->id, $battles);
// tests for hasOpenBattleAgainst()
$this->assertTrue($user1->hasOpenBattleAgainst($user2));
$this->assertTrue($user1->hasOpenBattleAgainst($user3));
$this->assertTrue($user2->hasOpenBattleAgainst($user1));
$this->assertTrue($user2->hasOpenBattleAgainst($user3));
$this->assertFalse($user1->hasOpenBattleAgainst($user4));
$this->assertFalse($user4->hasOpenBattleAgainst($user3));
// tests for scopeNoBattleRequestsAgainst()
$noba1 = $user1->noOpenBattleAgainst($user4)->lists('id')->toArray();
$this->assertContains($user4->id, $noba1);
$noba4 = $user4->noOpenBattleAgainst($user4)->lists('id')->toArray();
$this->assertContains($user1->id, $noba4);
$this->assertContains($user2->id, $noba4);
$this->assertContains($user3->id, $noba4);
}
/**
* Test for isOpen(), scopeOpen() and setPhaseAttribute()
*/
public function testIsOpen()
{
$battle11 = factory(App\Models\OpenBattle::class)->create();
$battle12 = factory(App\Models\OpenBattle::class)->create();
$battle21 = factory(App\Models\OpenBattle::class)->create();
$battle22 = factory(App\Models\OpenBattle::class)->create();
//$battle3 = factory(App\Models\OpenBattle::class)->create();
$battle11->setPhaseAttribute(1);
$battle21->setPhaseAttribute(2);
//$battle3->setPhaseAttribute(3);
$battle11->save();
$battle21->save();
//$battle3->save();
$now = Carbon::now();
Carbon::setTestNow(Carbon::now()->subHours(config('rap-battle.phase1time', 24) + 1));
$battle12->setPhaseAttribute(1);
$battle12->save();
Carbon::setTestNow(Carbon::now()->subHours(config('rap-battle.phase2time', 24) + 1));
$battle22->setPhaseAttribute(2);
$battle22->save();
// test phase
$this->assertEquals(1, $battle11->phase);
$this->assertEquals(1, $battle12->phase);
$this->assertEquals(2, $battle21->phase);
$this->assertEquals(2, $battle22->phase);
Carbon::setTestNow($now);
$this->assertTrue($battle11->isOpen());
$this->assertTrue($battle21->isOpen());
$this->assertFalse($battle12->isOpen());
$this->assertFalse($battle22->isOpen());
//$this->assertFalse($battle3->isOpen());
// test scopeOpen()
$cnt = OpenBattle::open()->count();
$this->assertEquals(2, $cnt);
// TODO: check if $battle11 and $battle21 are in $cnt
}
/**
* Accept or decline a battle request.
*
* @param \Illuminate\Http\Request $request
* @param integer $id
* @return void|\Illuminate\Http\Response
*/
public function postAnswer(Request $request, $id)
{
$this->validate($request, ['accepted' => 'required|boolean']);
$user = Auth::user();
if (is_null($user)) {
return response('Unauthorized', 401);
}
$battleRequest = BattleRequest::findOrFail($id);
// Check if authenticated user is challenged user
if ($battleRequest->challenged_id == $user->id) {
if ($request->input('accepted')) {
$battle = new OpenBattle();
$battle->start($battleRequest->challenger, $battleRequest->challenged);
$battle->save();
}
$battleRequest->delete();
} else {
return response('Unauthorized', 401);
}
}
/**
* Run the database seeds.
*
* @return void
*/
public function run()
{
Model::unguard();
// config
$usercnt = 20;
$userRappercnt = 20;
$battlecnt = 20;
$battleRequestcnt = rand($userRappercnt / 4, $userRappercnt / 2);
// max $userRappercnt / 2
$openBattlecnt = rand($userRappercnt / 4, $userRappercnt / 2);
// max $userRappercnt / 2
// create users
$users = factory(App\Models\User::class, $usercnt)->create();
// rapper and non-rapper
$usersRapper = factory(App\Models\User::class, 'rapper', $userRappercnt)->create();
// rapper only
//----------------------------------------------
// create battles
for ($i = 0; $i < $battlecnt; $i++) {
$battle = new Battle();
// get first rapper
$battle->rapper1_id = $usersRapper->random()->id;
// get second rapper != first rapper
do {
$battle->rapper2_id = $usersRapper->random()->id;
} while ($battle->rapper1_id == $battle->rapper2_id);
$battle->save();
//-----------------------------------------
// create votes
// create list of all created users
$usersAll = $users->keyBy('id')->merge($usersRapper->keyBy('id'));
$usersAll->shuffle();
$userVotescnt = rand(0, $usersAll->count());
for ($j = 0; $j < $userVotescnt; $j++) {
$vote = new Vote();
$vote->user_id = $usersAll->get($j)->id;
$vote->battle_id = $battle->id;
$vote->rapper_number = rand(0, 1);
$vote->save();
// update vote counter
if ($vote->rapper_number == 0) {
$battle->votes_rapper1++;
} else {
$battle->votes_rapper2++;
}
}
// save vote count in battle
$battle->save();
$battle->rapper1->updateRating();
$battle->rapper2->updateRating();
}
//----------------------------------------------
// create battle_requests
for ($i = 0; $i < $battleRequestcnt * 2; $i += 2) {
$battleRequest = new BattleRequest();
$battleRequest->challenger_id = $usersRapper->get($i)->id;
$battleRequest->challenged_id = $usersRapper->get($i + 1)->id;
$battleRequest->save();
}
//----------------------------------------------
// create open battles
$usersRapper->shuffle();
for ($i = 0; $i < $openBattlecnt * 2; $i += 2) {
$openBattle = new OpenBattle();
$openBattle->rapper1_id = $usersRapper->get($i)->id;
$openBattle->rapper2_id = $usersRapper->get($i + 1)->id;
$openBattle->phase = rand(1, 2);
// TODO: how many phases?
$openBattle->beat1_id = rand(0, 2);
$openBattle->beat2_id = rand(0, 2);
$openBattle->save();
}
Model::reguard();
}
/**
* Check if this user has an open battle $user
*/
public function hasOpenBattleAgainst(User $user)
{
//$cnt = $this->openBattles()->where('rapper1_id', $user->id)->orWhere('rapper2_id', $user->id)->count();
//return $cnt > 0;
// possibly naive solution, other one had really ugly bugs
$cnt1 = OpenBattle::where('rapper1_id', $this->id)->where('rapper2_id', $user->id)->open()->count();
$cnt2 = OpenBattle::where('rapper2_id', $this->id)->where('rapper1_id', $user->id)->open()->count();
return $cnt1 > 0 || $cnt2 > 0;
}
