app/Models/Protocol.php

   1 <?php
   2
   3 namespace App\Models;
   4
   5 use App\Events\ProtocolAdded;
   6 use Illuminate\Database\Eloquent\Factories\HasFactory;
   7 use Illuminate\Database\Eloquent\Model;
   8
   9 class Protocol extends Model
  10 {
  11         use HasFactory;
  12
  13         public static function applicationAccepted(Tournament $tournament, Application $application, User $user) {
  14                 $protocol = static::create([
  15                         'tournament_id' => $tournament->id,
  16                         'user_id' => $user->id,
  17                         'type' => 'application.accepted',
  18                         'details' => [
  19                                 'tournament' => static::tournamentMemo($tournament),
  20                                 'application' => static::applicationMemo($application),
  21                                 'user' => static::userMemo($application->user),
  22                         ],
  23                 ]);
  24                 ProtocolAdded::dispatch($protocol);
  25         }
  26
  27         public static function applicationReceived(Tournament $tournament, Application $application, User $user) {
  28                 $protocol = static::create([
  29                         'tournament_id' => $tournament->id,
  30                         'user_id' => $user->id,
  31                         'type' => 'application.received',
  32                         'details' => [
  33                                 'tournament' => static::tournamentMemo($tournament),
  34                                 'application' => static::applicationMemo($application),
  35                                 'user' => static::userMemo($application->user),
  36                         ],
  37                 ]);
  38                 ProtocolAdded::dispatch($protocol);
  39         }
  40
  41         public static function applicationRejected(Tournament $tournament, Application $application, User $user) {
  42                 $protocol = static::create([
  43                         'tournament_id' => $tournament->id,
  44                         'user_id' => $user->id,
  45                         'type' => 'application.rejected',
  46                         'details' => [
  47                                 'tournament' => static::tournamentMemo($tournament),
  48                                 'application' => static::applicationMemo($application),
  49                                 'user' => static::userMemo($application->user),
  50                         ],
  51                 ]);
  52                 ProtocolAdded::dispatch($protocol);
  53         }
  54
  55         public static function resultCommented(Tournament $tournament, Result $result, User $user) {
  56                 $protocol = static::create([
  57                         'tournament_id' => $tournament->id,
  58                         'user_id' => $user->id,
  59                         'type' => 'result.comment',
  60                         'details' => [
  61                                 'tournament' => static::tournamentMemo($tournament),
  62                                 'result' => static::resultMemo($result),
  63                                 'round' => static::roundMemo($result->round),
  64                         ],
  65                 ]);
  66                 ProtocolAdded::dispatch($protocol);
  67         }
  68
  69         public static function resultReported(Tournament $tournament, Result $result, User $user) {
  70                 $protocol = static::create([
  71                         'tournament_id' => $tournament->id,
  72                         'user_id' => $user->id,
  73                         'type' => 'result.report',
  74                         'details' => [
  75                                 'tournament' => static::tournamentMemo($tournament),
  76                                 'result' => static::resultMemo($result),
  77                                 'round' => static::roundMemo($result->round),
  78                         ],
  79                 ]);
  80                 ProtocolAdded::dispatch($protocol);
  81         }
  82
  83         public static function roundAdded(Tournament $tournament, Round $round, User $user) {
  84                 $protocol = static::create([
  85                         'tournament_id' => $tournament->id,
  86                         'user_id' => $user->id,
  87                         'type' => 'round.create',
  88                         'details' => [
  89                                 'tournament' => static::tournamentMemo($tournament),
  90                                 'round' => static::roundMemo($round),
  91                         ],
  92                 ]);
  93                 ProtocolAdded::dispatch($protocol);
  94         }
  95
  96         public static function roundLocked(Tournament $tournament, Round $round, User $user = null) {
  97                 $protocol = static::create([
  98                         'tournament_id' => $tournament->id,
  99                         'user_id' => $user ? $user->id : null,
 100                         'type' => 'round.lock',
 101                         'details' => [
 102                                 'tournament' => static::tournamentMemo($tournament),
 103                                 'round' => static::roundMemo($round),
 104                         ],
 105                 ]);
 106                 ProtocolAdded::dispatch($protocol);
 107         }
 108
 109         public static function roundSeedSet(Tournament $tournament, Round $round, User $user) {
 110                 $protocol = static::create([
 111                         'tournament_id' => $tournament->id,
 112                         'user_id' => $user->id,
 113                         'type' => 'round.create',
 114                         'details' => [
 115                                 'tournament' => static::tournamentMemo($tournament),
 116                                 'round' => static::roundMemo($round),
 117                         ],
 118                 ]);
 119                 ProtocolAdded::dispatch($protocol);
 120         }
 121
 122         public static function roundUnlocked(Tournament $tournament, Round $round, User $user = null) {
 123                 $protocol = static::create([
 124                         'tournament_id' => $tournament->id,
 125                         'user_id' => $user ? $user->id : null,
 126                         'type' => 'round.unlock',
 127                         'details' => [
 128                                 'tournament' => static::tournamentMemo($tournament),
 129                                 'round' => static::roundMemo($round),
 130                         ],
 131                 ]);
 132                 ProtocolAdded::dispatch($protocol);
 133         }
 134
 135         public static function tournamentCreated(Tournament $tournament, User $user) {
 136                 $protocol = static::create([
 137                         'tournament_id' => $tournament->id,
 138                         'user_id' => $user->id,
 139                         'type' => 'tournament.create',
 140                         'details' => [
 141                                 'tournament' => static::tournamentMemo($tournament),
 142                         ],
 143                 ]);
 144                 ProtocolAdded::dispatch($protocol);
 145         }
 146
 147         public static function tournamentLocked(Tournament $tournament, User $user = null) {
 148                 $protocol = static::create([
 149                         'tournament_id' => $tournament->id,
 150                         'user_id' => $user ? $user->id : null,
 151                         'type' => 'tournament.lock',
 152                         'details' => [
 153                                 'tournament' => static::tournamentMemo($tournament),
 154                         ],
 155                 ]);
 156                 ProtocolAdded::dispatch($protocol);
 157         }
 158
 159
 160         protected static function applicationMemo(Application $application) {
 161                 return [
 162                         'id' => $application->id,
 163                         'denied' => $application->denied,
 164                 ];
 165         }
 166
 167         protected static function resultMemo(Result $result) {
 168                 return [
 169                         'id' => $result->id,
 170                         'comment' => $result->comment,
 171                         'forfeit' => $result->forfeit,
 172                         'time' => $result->time,
 173                 ];
 174         }
 175
 176         protected static function roundMemo(Round $round) {
 177                 return [
 178                         'id' => $round->id,
 179                         'locked' => $round->locked,
 180                         'no_record' => $round->no_record,
 181                         'number' => $round->number,
 182                         'seed' => $round->seed,
 183                 ];
 184         }
 185
 186         protected static function tournamentMemo(Tournament $tournament) {
 187                 return [
 188                         'id' => $tournament->id,
 189                         'accept_applications' => $tournament->accept_applications,
 190                         'locked' => $tournament->locked,
 191                         'no_record' => $tournament->no_record,
 192                         'title' => $tournament->title,
 193                 ];
 194         }
 195
 196         protected static function userMemo(User $user) {
 197                 return [
 198                         'id' => $user->id,
 199                         'username' => $user->username,
 200                         'discriminator' => $user->discriminator,
 201                         'avatar' => $user->avatar,
 202                         'nickname' => $user->nickname,
 203                 ];
 204         }
 205
 206
 207         public function tournament() {
 208                 return $this->belongsTo(Tournament::class);
 209         }
 210
 211         public function user() {
 212                 return $this->belongsTo(User::class);
 213         }
 214
 215
 216         protected $casts = [
 217                 'details' => 'array',
 218         ];
 219
 220         protected $fillable = [
 221                 'details',
 222                 'tournament_id',
 223                 'type',
 224                 'user_id',
 225         ];
 226
 227 }