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 roundEdited(Tournament $tournament, Round $round, User $user) {
  97                 $protocol = static::create([
  98                         'tournament_id' => $tournament->id,
  99                         'user_id' => $user->id,
 100                         'type' => 'round.edit',
 101                         'details' => [
 102                                 'tournament' => static::tournamentMemo($tournament),
 103                                 'round' => static::roundMemo($round),
 104                         ],
 105                 ]);
 106                 ProtocolAdded::dispatch($protocol);
 107         }
 108
 109         public static function roundLocked(Tournament $tournament, Round $round, User $user = null) {
 110                 $protocol = static::create([
 111                         'tournament_id' => $tournament->id,
 112                         'user_id' => $user ? $user->id : null,
 113                         'type' => 'round.lock',
 114                         'details' => [
 115                                 'tournament' => static::tournamentMemo($tournament),
 116                                 'round' => static::roundMemo($round),
 117                         ],
 118                 ]);
 119                 ProtocolAdded::dispatch($protocol);
 120         }
 121
 122         public static function roundSeedSet(Tournament $tournament, Round $round, User $user) {
 123                 $protocol = static::create([
 124                         'tournament_id' => $tournament->id,
 125                         'user_id' => $user->id,
 126                         'type' => 'round.seed',
 127                         'details' => [
 128                                 'tournament' => static::tournamentMemo($tournament),
 129                                 'round' => static::roundMemo($round),
 130                         ],
 131                 ]);
 132                 ProtocolAdded::dispatch($protocol);
 133         }
 134
 135         public static function roundUnlocked(Tournament $tournament, Round $round, User $user = null) {
 136                 $protocol = static::create([
 137                         'tournament_id' => $tournament->id,
 138                         'user_id' => $user ? $user->id : null,
 139                         'type' => 'round.unlock',
 140                         'details' => [
 141                                 'tournament' => static::tournamentMemo($tournament),
 142                                 'round' => static::roundMemo($round),
 143                         ],
 144                 ]);
 145                 ProtocolAdded::dispatch($protocol);
 146         }
 147
 148         public static function tournamentClosed(Tournament $tournament, User $user = null) {
 149                 $protocol = static::create([
 150                         'tournament_id' => $tournament->id,
 151                         'user_id' => $user ? $user->id : null,
 152                         'type' => 'tournament.close',
 153                         'details' => [
 154                                 'tournament' => static::tournamentMemo($tournament),
 155                         ],
 156                 ]);
 157                 ProtocolAdded::dispatch($protocol);
 158         }
 159
 160         public static function tournamentCreated(Tournament $tournament, User $user) {
 161                 $protocol = static::create([
 162                         'tournament_id' => $tournament->id,
 163                         'user_id' => $user->id,
 164                         'type' => 'tournament.create',
 165                         'details' => [
 166                                 'tournament' => static::tournamentMemo($tournament),
 167                         ],
 168                 ]);
 169                 ProtocolAdded::dispatch($protocol);
 170         }
 171
 172         public static function tournamentDiscord(Tournament $tournament, User $user = null) {
 173                 $protocol = static::create([
 174                         'tournament_id' => $tournament->id,
 175                         'user_id' => $user ? $user->id : null,
 176                         'type' => 'tournament.discord',
 177                         'details' => [
 178                                 'tournament' => static::tournamentMemo($tournament),
 179                         ],
 180                 ]);
 181                 ProtocolAdded::dispatch($protocol);
 182         }
 183
 184         public static function tournamentDiscordSettings(Tournament $tournament, User $user = null) {
 185                 $protocol = static::create([
 186                         'tournament_id' => $tournament->id,
 187                         'user_id' => $user ? $user->id : null,
 188                         'type' => 'tournament.discordSettings',
 189                         'details' => [
 190                                 'tournament' => static::tournamentMemo($tournament),
 191                         ],
 192                 ]);
 193                 ProtocolAdded::dispatch($protocol);
 194         }
 195
 196         public static function tournamentLocked(Tournament $tournament, User $user = null) {
 197                 $protocol = static::create([
 198                         'tournament_id' => $tournament->id,
 199                         'user_id' => $user ? $user->id : null,
 200                         'type' => 'tournament.lock',
 201                         'details' => [
 202                                 'tournament' => static::tournamentMemo($tournament),
 203                         ],
 204                 ]);
 205                 ProtocolAdded::dispatch($protocol);
 206         }
 207
 208         public static function tournamentOpened(Tournament $tournament, User $user = null) {
 209                 $protocol = static::create([
 210                         'tournament_id' => $tournament->id,
 211                         'user_id' => $user ? $user->id : null,
 212                         'type' => 'tournament.open',
 213                         'details' => [
 214                                 'tournament' => static::tournamentMemo($tournament),
 215                         ],
 216                 ]);
 217                 ProtocolAdded::dispatch($protocol);
 218         }
 219
 220         public static function tournamentSettings(Tournament $tournament, User $user = null) {
 221                 $protocol = static::create([
 222                         'tournament_id' => $tournament->id,
 223                         'user_id' => $user ? $user->id : null,
 224                         'type' => 'tournament.settings',
 225                         'details' => [
 226                                 'tournament' => static::tournamentMemo($tournament),
 227                         ],
 228                 ]);
 229                 ProtocolAdded::dispatch($protocol);
 230         }
 231
 232         public static function tournamentUnlocked(Tournament $tournament, User $user = null) {
 233                 $protocol = static::create([
 234                         'tournament_id' => $tournament->id,
 235                         'user_id' => $user ? $user->id : null,
 236                         'type' => 'tournament.unlock',
 237                         'details' => [
 238                                 'tournament' => static::tournamentMemo($tournament),
 239                         ],
 240                 ]);
 241                 ProtocolAdded::dispatch($protocol);
 242         }
 243
 244
 245         protected static function applicationMemo(Application $application) {
 246                 return [
 247                         'id' => $application->id,
 248                         'denied' => $application->denied,
 249                 ];
 250         }
 251
 252         protected static function resultMemo(Result $result) {
 253                 return [
 254                         'id' => $result->id,
 255                         'comment' => $result->comment,
 256                         'forfeit' => $result->forfeit,
 257                         'time' => $result->time,
 258                 ];
 259         }
 260
 261         protected static function roundMemo(Round $round) {
 262                 return [
 263                         'id' => $round->id,
 264                         'locked' => $round->locked,
 265                         'no_record' => $round->no_record,
 266                         'number' => $round->number,
 267                         'seed' => $round->seed,
 268                 ];
 269         }
 270
 271         protected static function tournamentMemo(Tournament $tournament) {
 272                 return [
 273                         'id' => $tournament->id,
 274                         'accept_applications' => $tournament->accept_applications,
 275                         'locked' => $tournament->locked,
 276                         'no_record' => $tournament->no_record,
 277                         'title' => $tournament->title,
 278                 ];
 279         }
 280
 281         protected static function userMemo(User $user) {
 282                 return [
 283                         'id' => $user->id,
 284                         'username' => $user->username,
 285                         'discriminator' => $user->discriminator,
 286                         'avatar' => $user->avatar,
 287                         'nickname' => $user->nickname,
 288                 ];
 289         }
 290
 291
 292         public function tournament() {
 293                 return $this->belongsTo(Tournament::class);
 294         }
 295
 296         public function user() {
 297                 return $this->belongsTo(User::class);
 298         }
 299
 300
 301         protected $casts = [
 302                 'details' => 'array',
 303                 'user_id' => 'string',
 304         ];
 305
 306         protected $fillable = [
 307                 'details',
 308                 'tournament_id',
 309                 'type',
 310                 'user_id',
 311         ];
 312
 313 }