m/\r/g
16 | """
17 |
18 | alias Ex338.{Repo, DraftPicks.DraftPick}
19 |
20 | def store_draft_picks(row) do
21 | changeset = DraftPick.changeset(%DraftPick{}, row)
22 | Repo.insert!(changeset)
23 | end
24 | end
25 |
26 | File.stream!("priv/repo/annual_league_setup/data/draft_picks.csv")
27 | |> Stream.drop(1)
28 | |> CSV.decode!(headers: [:draft_position, :fantasy_league_id, :fantasy_team_id,
29 | :fantasy_team_name])
30 | |> Enum.each(&Ex338.AnnualLeagueSetup.DraftData.store_draft_picks/1)
31 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20240308035310_create_users_auth_tables.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Repo.Migrations.CreateUsersAuthTables do
2 | @moduledoc false
3 | use Ecto.Migration
4 |
5 | def up do
6 | execute "CREATE EXTENSION IF NOT EXISTS citext", ""
7 |
8 | alter table(:users) do
9 | modify :email, :citext, null: false
10 | add :confirmed_at, :naive_datetime
11 | end
12 |
13 | create table(:users_tokens) do
14 | add :user_id, references(:users, on_delete: :delete_all), null: false
15 | add :token, :binary, null: false
16 | add :context, :string, null: false
17 | add :sent_to, :string
18 | timestamps(updated_at: false)
19 | end
20 |
21 | create index(:users_tokens, [:user_id])
22 | create unique_index(:users_tokens, [:context, :token])
23 | end
24 |
25 | def down do
26 | drop index(:users_tokens, [:context, :token])
27 | drop index(:users_tokens, [:user_id])
28 |
29 | drop table(:users_tokens)
30 |
31 | alter table(:users) do
32 | remove :confirmed_at
33 | modify :email, :string, null: false
34 | end
35 | end
36 | end
37 |
--------------------------------------------------------------------------------
/test/ex338/jobs_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.JobsTest do
2 | use Ex338.DataCase, async: true
3 | use Oban.Testing, repo: Ex338.Repo
4 |
5 | alias Ex338.CalendarAssistant
6 | alias Ex338.Jobs
7 |
8 | describe "get_autodraft_job_by/1" do
9 | test "starts autodraft for a championship and a fantasy_league" do
10 | fantasy_league = insert(:fantasy_league)
11 | championship = insert(:championship)
12 |
13 | five_mins = CalendarAssistant.mins_from_now(5)
14 |
15 | Oban.Testing.with_testing_mode(:manual, fn ->
16 | {:ok, job} =
17 | %{fantasy_league_id: fantasy_league.id, championship_id: championship.id}
18 | |> Ex338.Workers.InSeasonAutodraftWorker.new(scheduled_at: five_mins)
19 | |> Oban.insert()
20 |
21 | result =
22 | Jobs.get_autodraft_job_by(%{
23 | fantasy_league_id: fantasy_league.id,
24 | championship_id: championship.id
25 | })
26 |
27 | assert result.id == job.id
28 | assert DateTime.truncate(result.scheduled_at, :second) == five_mins
29 | end)
30 | end
31 | end
32 | end
33 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | MIT License
2 |
3 | Copyright (c) 2017 Axel Clark
4 |
5 | Permission is hereby granted, free of charge, to any person obtaining a copy
6 | of this software and associated documentation files (the "Software"), to deal
7 | in the Software without restriction, including without limitation the rights
8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 |
--------------------------------------------------------------------------------
/lib/ex338/workers/in_season_autodraft_worker.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Workers.InSeasonAutodraftWorker do
2 | @moduledoc false
3 | use Oban.Worker,
4 | max_attempts: 1
5 |
6 | alias Ex338.AutoDraft
7 | alias Ex338.Championships
8 |
9 | @thirty_seconds 30
10 |
11 | @impl Oban.Worker
12 | def perform(%Oban.Job{} = job) do
13 | %{args: %{"fantasy_league_id" => fantasy_league_id, "championship_id" => championship_id}} =
14 | job
15 |
16 | case make_in_season_draft_pick_from_queues(fantasy_league_id, championship_id) do
17 | {:ok, :in_season_draft_picks_complete} ->
18 | {:ok, :in_season_draft_picks_complete}
19 |
20 | result ->
21 | schedule_next_job(job)
22 | result
23 | end
24 | end
25 |
26 | defp make_in_season_draft_pick_from_queues(fantasy_league_id, championship_id) do
27 | championship = Championships.get_championship_by_league(championship_id, fantasy_league_id)
28 | AutoDraft.in_season_draft_pick_from_queues(fantasy_league_id, championship)
29 | end
30 |
31 | defp schedule_next_job(job) do
32 | job.args
33 | |> new(schedule_in: @thirty_seconds)
34 | |> Oban.insert()
35 | end
36 | end
37 |
--------------------------------------------------------------------------------
/lib/ex338_web/channels/user_socket.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.UserSocket do
2 | use Phoenix.Socket
3 |
4 | ## Channels
5 | # channel "room:*", Ex338.RoomChannel
6 |
7 | # Socket params are passed from the client and can
8 | # be used to verify and authenticate a user. After
9 | # verification, you can put default assigns into
10 | # the socket that will be set for all channels, ie
11 | #
12 | # {:ok, assign(socket, :user_id, verified_user_id)}
13 | #
14 | # To deny connection, return `:error`.
15 | #
16 | # See `Phoenix.Token` documentation for examples in
17 | # performing token verification on connect.
18 | def connect(_params, socket) do
19 | {:ok, socket}
20 | end
21 |
22 | # Socket id's are topics that allow you to identify sockets for a given user:
23 | #
24 | # def id(socket), do: "users_socket:#{socket.assigns.user_id}"
25 | #
26 | # Would allow you to broadcast a "disconnect" event and terminate
27 | # all active sockets and channels for a given user:
28 | #
29 | # Ex338.Endpoint.broadcast("users_socket:#{user.id}", "disconnect", %{})
30 | #
31 | # Returning `nil` makes this socket anonymous.
32 | def id(_socket), do: nil
33 | end
34 |
--------------------------------------------------------------------------------
/assets/css/live_view.css:
--------------------------------------------------------------------------------
1 | /* LiveView specific classes for your customizations */
2 | .invalid-feedback {
3 | color: #a94442;
4 | display: block;
5 | margin: -1rem 0 2rem;
6 | }
7 |
8 | .phx-no-feedback.invalid-feedback, .phx-no-feedback .invalid-feedback {
9 | display: none;
10 | }
11 |
12 | .phx-click-loading {
13 | opacity: 0.5;
14 | transition: opacity 1s ease-out;
15 | }
16 |
17 | .phx-disconnected{
18 | cursor: wait;
19 | }
20 | .phx-disconnected *{
21 | pointer-events: none;
22 | }
23 |
24 | .phx-modal {
25 | opacity: 1!important;
26 | position: fixed;
27 | z-index: 1;
28 | left: 0;
29 | top: 0;
30 | width: 100%;
31 | height: 100%;
32 | overflow: auto;
33 | background-color: rgb(0,0,0);
34 | background-color: rgba(0,0,0,0.4);
35 | }
36 |
37 | .phx-modal-content {
38 | background-color: #fefefe;
39 | margin: 15% auto;
40 | padding: 20px;
41 | border: 1px solid #888;
42 | width: 80%;
43 | }
44 |
45 | .phx-modal-close {
46 | color: #aaa;
47 | float: right;
48 | font-size: 28px;
49 | font-weight: bold;
50 | }
51 |
52 | .phx-modal-close:hover,
53 | .phx-modal-close:focus {
54 | color: black;
55 | text-decoration: none;
56 | cursor: pointer;
57 | }
58 |
--------------------------------------------------------------------------------
/test/support/channel_case.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.ChannelCase do
2 | @moduledoc """
3 | This module defines the test case to be used by
4 | channel tests.
5 |
6 | Such tests rely on `Phoenix.ChannelTest` and also
7 | import other functionality to make it easier
8 | to build and query models.
9 |
10 | Finally, if the test case interacts with the database,
11 | it cannot be async. For this reason, every test runs
12 | inside a transaction which is reset at the beginning
13 | of the test unless the test case is marked as async.
14 | """
15 |
16 | use ExUnit.CaseTemplate
17 |
18 | alias Ecto.Adapters.SQL.Sandbox
19 |
20 | using do
21 | quote do
22 | # Import conveniences for testing with channels
23 | use Phoenix.ChannelTest
24 |
25 | import Ecto
26 | import Ecto.Changeset
27 | import Ecto.Query
28 |
29 | alias Ex338.Repo
30 |
31 | # The default endpoint for testing
32 | @endpoint Ex338Web.Endpoint
33 | end
34 | end
35 |
36 | setup tags do
37 | :ok = Sandbox.checkout(Ex338.Repo)
38 |
39 | if !tags[:async] do
40 | Sandbox.mode(Ex338.Repo, {:shared, self()})
41 | end
42 |
43 | :ok
44 | end
45 | end
46 |
--------------------------------------------------------------------------------
/test/ex338_web/controllers/owner_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.OwnerControllerTest do
2 | use Ex338Web.ConnCase
3 |
4 | describe "index/2" do
5 | test "lists all owners in a league", %{conn: conn} do
6 | league = insert(:fantasy_league)
7 | other_league = insert(:fantasy_league)
8 | team = insert(:fantasy_team, team_name: "Brown", fantasy_league: league)
9 |
10 | other_team =
11 | insert(
12 | :fantasy_team,
13 | team_name: "Another Team",
14 | fantasy_league: other_league
15 | )
16 |
17 | user = insert_user(%{name: "Brown", email: "brown@example.com"})
18 | other_user = insert_user(%{name: "Axel", email: "axel@example.com"})
19 | insert(:owner, fantasy_team: team, user: user)
20 | insert(:owner, fantasy_team: other_team, user: other_user)
21 |
22 | conn = get(conn, ~p"/fantasy_leagues/#{league.id}/owners")
23 |
24 | assert html_response(conn, 200) =~ ~r/Owners/
25 | assert String.contains?(conn.resp_body, team.team_name)
26 | assert String.contains?(conn.resp_body, user.name)
27 | refute String.contains?(conn.resp_body, other_team.team_name)
28 | end
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/.iex.exs:
--------------------------------------------------------------------------------
1 | import Ecto.Query
2 |
3 | alias Ex338.Accounts.User
4 | alias Ex338.CalendarAssistant
5 | alias Ex338.Championships
6 | alias Ex338.Championships.Championship
7 | alias Ex338.Championships.ChampionshipResult
8 | alias Ex338.Championships.ChampionshipSlot
9 | alias Ex338.Championships.ChampWithEventsResult
10 | alias Ex338.DraftPicks
11 | alias Ex338.DraftPicks.Admin
12 | alias Ex338.DraftPicks.DraftPick
13 | alias Ex338.DraftQueues
14 | alias Ex338.DraftQueues.DraftQueue
15 | alias Ex338.FantasyLeagues
16 | alias Ex338.FantasyLeagues.FantasyLeague
17 | alias Ex338.FantasyPlayers
18 | alias Ex338.FantasyPlayers.FantasyPlayer
19 | alias Ex338.FantasyPlayers.SportsLeague
20 | alias Ex338.FantasyTeams
21 | alias Ex338.FantasyTeams.FantasyTeam
22 | alias Ex338.FantasyTeams.Owner
23 | alias Ex338.InjuredReserves
24 | alias Ex338.InSeasonDraftPicks
25 | alias Ex338.Mailer
26 | alias Ex338.NotificationEmail
27 | alias Ex338.Repo
28 | alias Ex338.RosterPositions
29 | alias Ex338.RosterPositions.Admin
30 | alias Ex338.RosterPositions.RosterPosition
31 | alias Ex338.Trades
32 | alias Ex338.Trades.Trade
33 | alias Ex338.Trades.TradeLineItem
34 | alias Ex338.Waivers
35 | alias Ex338.Waivers.Admin
36 | alias Ex338.Waivers.Waiver
37 |
--------------------------------------------------------------------------------
/lib/ex338_web/controllers/commish_email_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.CommishEmailController do
2 | use Ex338Web, :controller
3 |
4 | alias Ex338.FantasyLeagues.FantasyLeague
5 | alias Ex338.Repo
6 | alias Ex338Web.CommishNotifier
7 |
8 | require Logger
9 |
10 | def new(conn, _params) do
11 | render(
12 | conn,
13 | :new,
14 | fantasy_leagues: Repo.all(FantasyLeague),
15 | page_title: "Commish Email"
16 | )
17 | end
18 |
19 | def create(conn, %{
20 | "commish_email" => %{"leagues" => leagues, "subject" => subject, "message" => message}
21 | }) do
22 | result = CommishNotifier.send_email_to_leagues(leagues, subject, message)
23 |
24 | case result do
25 | {:ok, result} ->
26 | Logger.info("Commish email sent successfully: #{inspect(result)}")
27 |
28 | conn
29 | |> put_flash(:info, "Email sent successfully")
30 | |> redirect(to: ~p"/commish_email/new")
31 |
32 | {:error, reason} ->
33 | Logger.error("Commish email failed: #{inspect(reason)}")
34 |
35 | conn
36 | |> put_flash(:error, "Email failed to send: #{reason}")
37 | |> redirect(to: ~p"/commish_email/new")
38 | end
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/ex338/fantasy_teams/deadlines.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.FantasyTeams.Deadlines do
2 | @moduledoc """
3 | Adds deadline booleans to roster positions
4 | """
5 |
6 | def add_for_league(teams) do
7 | Enum.map(teams, &add_for_team(&1))
8 | end
9 |
10 | def add_for_team(%{roster_positions: positions} = team) do
11 | positions = update_positions(positions)
12 |
13 | %{team | roster_positions: positions}
14 | end
15 |
16 | ## Implementations
17 |
18 | ## add_for_team
19 |
20 | defp update_positions(positions) do
21 | Enum.map(positions, &update_position/1)
22 | end
23 |
24 | defp update_position(
25 | %{fantasy_player: %{sports_league: %{championships: [overall]}}} = position
26 | ) do
27 | overall = Ex338.Championships.Championship.add_deadline_statuses(overall)
28 |
29 | update_championship(position, overall)
30 | end
31 |
32 | defp update_position(position), do: position
33 |
34 | defp update_championship(position, championship) do
35 | put_in(
36 | position,
37 | [
38 | Access.key(:fantasy_player),
39 | Access.key(:sports_league),
40 | Access.key(:championships),
41 | Access.at(0)
42 | ],
43 | championship
44 | )
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/test/ex338/fantasy_leagues/historical_winning_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.FantasyLeagues.HistoricalWinningTest do
2 | use Ex338.DataCase, aysnc: true
3 |
4 | alias Ex338.FantasyLeagues.HistoricalWinning
5 |
6 | describe "changeset/2" do
7 | @valid_attrs %{
8 | team: "Brown",
9 | amount: 213
10 | }
11 | test "changeset with valid attributes" do
12 | changeset = HistoricalWinning.changeset(%HistoricalWinning{}, @valid_attrs)
13 | assert changeset.valid?
14 | end
15 |
16 | @invalid_attrs %{
17 | team: "",
18 | amount: 0
19 | }
20 | test "changeset with invalid attributes" do
21 | changeset = HistoricalWinning.changeset(%HistoricalWinning{}, @invalid_attrs)
22 | refute changeset.valid?
23 | end
24 | end
25 |
26 | describe "order_by_amount/1" do
27 | test "orders winnings by amount" do
28 | a = insert(:historical_winning, amount: 100)
29 | b = insert(:historical_winning, amount: 300)
30 | c = insert(:historical_winning, amount: 200)
31 |
32 | result =
33 | HistoricalWinning
34 | |> HistoricalWinning.order_by_amount()
35 | |> Repo.all()
36 |
37 | assert Enum.map(result, & &1.id) == [b.id, c.id, a.id]
38 | end
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/test/ex338_web/live/fantasy_league_live/show_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.FantasyLeagueLive.ShowTest do
2 | use Ex338Web.ConnCase
3 |
4 | import Phoenix.LiveViewTest
5 |
6 | describe "show/2" do
7 | test "shows league and lists all fantasy teams", %{conn: conn} do
8 | league = insert(:fantasy_league)
9 |
10 | team_1 =
11 | insert(:fantasy_team, team_name: "Brown", fantasy_league: league, winnings_adj: 20.00)
12 |
13 | team_2 = insert(:fantasy_team, team_name: "Axel", fantasy_league: league, dues_paid: 100.00)
14 | player = insert(:fantasy_player)
15 | insert(:roster_position, fantasy_team: team_1, fantasy_player: player, status: "active")
16 | insert(:championship_result, points: 8, rank: 1, fantasy_player: player)
17 |
18 | insert(
19 | :champ_with_events_result,
20 | points: 8.0,
21 | rank: 1,
22 | winnings: 25.00,
23 | fantasy_team: team_1
24 | )
25 |
26 | {:ok, _view, html} = live(conn, ~p"/fantasy_leagues/#{league.id}")
27 |
28 | assert html =~ "Standings"
29 | assert html =~ team_1.team_name
30 | assert html =~ team_2.team_name
31 | assert html =~ "100"
32 | assert html =~ "16.0"
33 | assert html =~ "$70"
34 | end
35 | end
36 | end
37 |
--------------------------------------------------------------------------------
/lib/ex338/trades/trade_vote.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Trades.TradeVote do
2 | @moduledoc false
3 | use Ecto.Schema
4 |
5 | import Ecto.Changeset
6 |
7 | alias Ex338.Trades.TradeVote
8 |
9 | schema "trade_votes" do
10 | field(:approve, :boolean, default: true)
11 | belongs_to(:trade, Ex338.Trades.Trade)
12 | belongs_to(:fantasy_team, Ex338.FantasyTeams.FantasyTeam)
13 | belongs_to(:user, Ex338.Accounts.User)
14 |
15 | timestamps()
16 | end
17 |
18 | def assoc_changeset(%TradeVote{} = trade_vote, attrs) do
19 | trade_vote
20 | |> cast(attrs, [:approve, :fantasy_team_id, :user_id])
21 | |> validate_required([:approve, :fantasy_team_id, :user_id])
22 | |> unique_constraint(
23 | :trade,
24 | name: :trade_votes_trade_id_fantasy_team_id_index,
25 | message: "Team has already voted"
26 | )
27 | end
28 |
29 | @doc false
30 | def changeset(%TradeVote{} = trade_vote, attrs) do
31 | trade_vote
32 | |> cast(attrs, [:approve, :trade_id, :fantasy_team_id, :user_id])
33 | |> validate_required([:approve, :trade_id, :fantasy_team_id, :user_id])
34 | |> unique_constraint(
35 | :trade,
36 | name: :trade_votes_trade_id_fantasy_team_id_index,
37 | message: "Team has already voted"
38 | )
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/lib/ex338_web/controllers/commish_email_html.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.CommishEmailHTML do
2 | use Ex338Web, :html
3 |
4 | alias Ex338.FantasyLeagues
5 |
6 | def new(assigns) do
7 | ~H"""
8 | <.two_col_form
9 | :let={f}
10 | for={@conn}
11 | as={:commish_email}
12 | action={~p"/commish_email"}
13 | show_form_error={false}
14 | >
15 | <:title>
16 | Send an email to fantasy leagues
17 |
18 | <:description>
19 | Select one or more leagues to send an email.
20 |
21 |
22 | <.input
23 | field={f[:leagues]}
24 | label="Select leagues to email"
25 | type="select"
26 | multiple
27 | options={FantasyLeagues.format_leagues_for_select(@fantasy_leagues)}
28 | />
29 |
30 | Hold CTRL (Windows) or Command (Mac) to select multiple leagues
31 |
32 | <.input field={f[:subject]} label="Subject" type="text" required />
33 | <.input field={f[:message]} label="Message" type="textarea" required rows={6} />
34 | <:actions>
35 | <.submit_buttons back_route={~p"/"} submit_text="Send" />
36 |
37 |
38 | """
39 | end
40 | end
41 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Ex338
2 |
3 | A web application to manage the 338 Challenge Fantasy League built using [Elixir](https://elixir-lang.org/)
4 | and [Phoenix](http://www.phoenixframework.org/). The 338 Challenge is a
5 | fantasy sports league where you pick teams instead of players and get points
6 | when your team wins its league championship.
7 |
8 | The draft, waivers, and trades are accomplished through the website. The league
9 | is set up to have multiple divisions (with relegation).
10 |
11 | ### Home Page
12 |
13 | 
14 |
15 |
16 |
17 |
18 | ### List of Players
19 |
20 | 
21 |
22 | ## Setup
23 |
24 | To start your Phoenix server:
25 |
26 | - Run `mix setup` to install and setup dependencies
27 | - Start Phoenix endpoint with `mix phx.server` or inside IEx with `iex -S mix phx.server`
28 |
29 | Now you can visit [`localhost:4000`](http://localhost:4000) from your browser.
30 |
31 | ## Contributing
32 |
33 | 1. Fork it!
34 | 2. Create your feature branch: `git checkout -b my-new-feature`
35 | 3. Commit your changes: `git commit -am 'Add some feature'`
36 | 4. Push to the branch: `git push origin my-new-feature`
37 | 5. Submit a pull request :D
38 |
--------------------------------------------------------------------------------
/lib/ex338/draft_picks/future_pick.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.DraftPicks.FuturePick do
2 | @moduledoc false
3 | use Ecto.Schema
4 |
5 | import Ecto.Changeset
6 | import Ecto.Query, warn: false
7 |
8 | alias Ex338.FantasyTeams.FantasyTeam
9 |
10 | schema "future_picks" do
11 | field(:round, :integer)
12 | belongs_to(:original_team, FantasyTeam, foreign_key: :original_team_id)
13 | belongs_to(:current_team, FantasyTeam, foreign_key: :current_team_id)
14 |
15 | timestamps()
16 | end
17 |
18 | def by_league(query, fantasy_league_id) do
19 | from(
20 | p in query,
21 | join: t in assoc(p, :current_team),
22 | where: t.fantasy_league_id == ^fantasy_league_id
23 | )
24 | end
25 |
26 | @doc false
27 | def changeset(future_pick, attrs) do
28 | future_pick
29 | |> cast(attrs, [:round, :original_team_id, :current_team_id])
30 | |> validate_required([:round, :original_team_id, :current_team_id])
31 | end
32 |
33 | def preload_assocs(query) do
34 | from(
35 | p in query,
36 | preload: [:current_team, :original_team]
37 | )
38 | end
39 |
40 | def sort_by_round_and_team(query) do
41 | from(
42 | p in query,
43 | join: t in assoc(p, :current_team),
44 | order_by: [t.team_name, p.round]
45 | )
46 | end
47 | end
48 |
--------------------------------------------------------------------------------
/lib/ex338/fantasy_leagues/historical_record.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.FantasyLeagues.HistoricalRecord do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 |
6 | import Ecto.Changeset
7 | import Ecto.Query, warn: false
8 |
9 | schema "historical_records" do
10 | field(:description, :string)
11 | field(:record, :string)
12 | field(:team, :string)
13 | field(:year, :string)
14 | field(:order, :float)
15 | field(:type, HistoricalRecordTypeEnum, default: "season")
16 | field(:archived, :boolean)
17 |
18 | timestamps()
19 | end
20 |
21 | def all_time_records(query) do
22 | from(r in query, where: r.type == "all_time")
23 | end
24 |
25 | @doc """
26 | Builds a changeset based on the `struct` and `params`.
27 | """
28 | def changeset(record, params \\ %{}) do
29 | record
30 | |> cast(params, [:archived, :description, :order, :record, :team, :type, :year])
31 | |> validate_required([:archived, :description, :record, :team, :type])
32 | end
33 |
34 | def current_records(query) do
35 | from(r in query, where: r.archived == false)
36 | end
37 |
38 | def season_records(query) do
39 | from(r in query, where: r.type == "season")
40 | end
41 |
42 | def sorted_by_order(query) do
43 | from(r in query, order_by: [asc: r.order])
44 | end
45 | end
46 |
--------------------------------------------------------------------------------
/lib/ex338_web/live/commish/fantasy_league_live/edit.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.Commish.FantasyLeagueLive.Edit do
2 | @moduledoc false
3 | use Ex338Web, :live_view
4 |
5 | alias Ex338.FantasyLeagues
6 | alias Ex338Web.Components.Commish
7 |
8 | @impl true
9 | def render(assigns) do
10 | ~H"""
11 |
12 |
13 | <.live_component
14 | module={Ex338Web.Commish.FantasyLeagueLive.FormComponent}
15 | id={@fantasy_league.id}
16 | title={@page_title}
17 | action={@live_action}
18 | fantasy_league={@fantasy_league}
19 | return_to={~p"/commish/fantasy_leagues/#{@fantasy_league}/edit"}
20 | >
21 |
22 | """
23 | end
24 |
25 | @impl true
26 | def mount(_params, _session, socket) do
27 | {:ok, socket}
28 | end
29 |
30 | @impl true
31 | def handle_params(%{"id" => id}, _, socket) do
32 | fantasy_league = FantasyLeagues.get_fantasy_league_with_teams!(id)
33 |
34 | socket =
35 | socket
36 | |> assign(:page_title, "Edit Fantasy League")
37 | |> assign(:fantasy_league, fantasy_league)
38 | |> assign(
39 | :current_route,
40 | ~p"/commish/fantasy_leagues/#{fantasy_league}/edit"
41 | )
42 |
43 | {:noreply, socket}
44 | end
45 | end
46 |
--------------------------------------------------------------------------------
/lib/ex338_web/mailer.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.Mailer do
2 | @moduledoc false
3 | use Swoosh.Mailer, otp_app: :ex338
4 |
5 | require Logger
6 |
7 | def handle_delivery({:ok, result}) do
8 | Logger.info("Sent email notification")
9 | {:ok, result}
10 | end
11 |
12 | def handle_delivery({:error, {_, reason}}) do
13 | Logger.error("Email failed to send: #{inspect(reason)}")
14 | {:error, reason}
15 | end
16 |
17 | def build_and_deliver(recipient, subject, body) do
18 | email =
19 | Swoosh.Email.new(
20 | to: recipient,
21 | from: default_from_name_and_email(),
22 | subject: subject,
23 | html_body:
24 | body
25 | |> Phoenix.HTML.html_escape()
26 | |> Phoenix.HTML.safe_to_string()
27 | )
28 |
29 | case deliver(email) do
30 | {:ok, _} ->
31 | Logger.info("Sent email notification")
32 | {:ok, email}
33 |
34 | {:error, {_, reason}} ->
35 | Logger.warning("Sending email failed: #{inspect(reason)}")
36 | {:error, reason}
37 | end
38 | end
39 |
40 | def default_from_name_and_email do
41 | email_address = Application.fetch_env!(:ex338, :mailer_default_from_email)
42 | name = Application.fetch_env!(:ex338, :mailer_default_from_name)
43 |
44 | {name, email_address}
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/priv/repo/annual_league_setup/data/owners.csv:
--------------------------------------------------------------------------------
1 | Fantasy Team Id,Team Name,2017 Fantasy Team Id,User Id
2 | 68,Brown,31,4
3 | 69,The Consortium,32,45
4 | 69,,32,10
5 | 69,,32,7
6 | 70,Kintz/Mori,33,44
7 | 70,,33,21
8 | 71,Axel,34,3
9 | 72,BD,35,5
10 | 73,Bartch,36,19
11 | 74,Wilson,37,35
12 | 74,,37,20
13 | 75,Miller/Wernz,38,24
14 | 75,,38,11
15 | 76,FloPow,39,42
16 | 76,,39,37
17 | 77,G-Brew,40,30
18 | 77,,40,25
19 | 78,Davie/Paul,41,36
20 | 78,,41,27
21 | 79,Bro/Heli,42,34
22 | 79,,42,6
23 | 80,Jake,43,41
24 | 81,Zach,44,40
25 | 82,Vondy/Clark,45,22
26 | 82,,45,15
27 | 83,Adam/Mike,46,33
28 | 83,,46,56
29 | 84,Evan,47,31
30 | 85,Hughes,48,43
31 | 86,Sister-Sister,49,14
32 | 86,,49,8
33 | 87,Murphy's Law,50,13
34 | 88,Tim,51,38
35 | 89,Mike,52,12
36 | 89,,52,58
37 | 90,Riss/Ehrman,53,17
38 | 90,,53,9
39 | 91,Bailey,54,29
40 | 92,Nelson,55,23
41 | 93,Teeter,56,16
42 | 94,Mick/Jason,57,26
43 | 94,,57,18
44 | 95,Tom,58,32
45 | 98,Tom/Josh,61,52
46 | 98,,61,51
47 | 96,Danger 338,62,57
48 | 97,THE LIFE OF JASO,63,54
49 | 103,Mick/Jackson,64,18
50 | 99,Christian/Zach,65,55
51 | 100,Scotchy-Scotch,66,59
52 | 101,Cody,NA,69
53 | 102,Ryan/Aaron,60,53
54 | 102,,60,63
55 | 103,Mick/Jackson,NA,62
56 | 103,,NA,18
57 | 104,Ross,NA,64
58 | 105,Gavin/Sahil,NA,65
59 | 105,,NA,14
60 | 106,Zach Taylor,NA,66
61 | 107,Jim,NA,67
62 | 108,Marcus,NA,68
63 | 109,Matthius/Casey,NA,54
64 | 109,,NA,10
65 |
--------------------------------------------------------------------------------
/lib/ex338_web/live/fantasy_league_live/standings_chart_component.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.FantasyLeagueLive.StandingsChartComponent do
2 | @moduledoc false
3 | use Ex338Web, :live_component
4 |
5 | @impl true
6 | def update(%{standings_chart_data: data}, socket) do
7 | spec =
8 | [title: "Standings History", width: :container, height: :container]
9 | |> VegaLite.new()
10 | |> VegaLite.data_from_values(data, only: ["date", "points", "team_name"])
11 | |> VegaLite.mark(:line)
12 | |> VegaLite.encode_field(:x, "date", type: :temporal)
13 | |> VegaLite.encode_field(:y, "points", type: :quantitative)
14 | |> VegaLite.encode_field(:color, "team_name", type: :nominal, scale: [scheme: "category20"])
15 | # Output the specifcation
16 | |> VegaLite.to_spec()
17 |
18 | socket = assign(socket, id: socket.id)
19 | {:ok, push_event(socket, "vega_lite:#{socket.id}:init", %{"spec" => spec})}
20 | end
21 |
22 | @impl true
23 | def render(assigns) do
24 | ~H"""
25 |
36 | """
37 | end
38 | end
39 |
--------------------------------------------------------------------------------
/test/ex338_web/controllers/waiver_index_controller_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.WaiverIndexControllerTest do
2 | use Ex338Web.ConnCase
3 |
4 | describe "index/2" do
5 | test "lists all waivers in a league", %{conn: conn} do
6 | league = insert(:fantasy_league)
7 | other_league = insert(:fantasy_league)
8 | team = insert(:fantasy_team, team_name: "Brown", fantasy_league: league)
9 | player = insert(:fantasy_player)
10 | player2 = insert(:fantasy_player)
11 |
12 | other_team =
13 | insert(
14 | :fantasy_team,
15 | team_name: "Another Team",
16 | fantasy_league: other_league
17 | )
18 |
19 | insert(:waiver, fantasy_team: team, add_fantasy_player: player, status: "successful")
20 | insert(:waiver, fantasy_team: other_team, add_fantasy_player: player, status: "successful")
21 | insert(:waiver, fantasy_team: team, add_fantasy_player: player2, status: "pending")
22 |
23 | conn = get(conn, ~p"/fantasy_leagues/#{league.id}/waivers")
24 |
25 | assert html_response(conn, 200) =~ ~r/Waivers/
26 | assert String.contains?(conn.resp_body, team.team_name)
27 | assert String.contains?(conn.resp_body, player.player_name)
28 | assert String.contains?(conn.resp_body, player2.player_name)
29 | refute String.contains?(conn.resp_body, other_team.team_name)
30 | end
31 | end
32 | end
33 |
--------------------------------------------------------------------------------
/lib/ex338_web/controllers/owner_html.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.OwnerHTML do
2 | use Ex338Web, :html
3 |
4 | def index(assigns) do
5 | ~H"""
6 | <.page_header class="sm:mb-6">
7 | League Owners
8 |
9 |
10 | <.legacy_table>
11 |
12 |
13 | <.legacy_th>
14 | Fantasy Team
15 |
16 | <.legacy_th>
17 | Owner
18 |
19 | <.legacy_th>
20 | Slack Name
21 |
22 |
23 |
24 |
25 | <%= for owner <- @owners do %>
26 |
27 | <.legacy_td class="text-indigo-700">
28 | <.fantasy_team_name_link fantasy_team={owner.fantasy_team} />
29 |
30 | <.legacy_td class="text-indigo-700">
31 | <.link href={~p"/users/#{owner.user.id}"}>
32 | {owner.user.name}
33 |
34 |
35 | <.legacy_td>
36 | <%= if owner.user.slack_name == "" do %>
37 | --
38 | <% else %>
39 | {owner.user.slack_name}
40 | <% end %>
41 |
42 |
43 | <% end %>
44 |
45 |
46 | """
47 | end
48 | end
49 |
--------------------------------------------------------------------------------
/lib/ex338/roster_positions.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.RosterPositions do
2 | @moduledoc false
3 |
4 | alias Ex338.FantasyLeagues.FantasyLeague
5 | alias Ex338.FantasyPlayers
6 | alias Ex338.Repo
7 | alias Ex338.RosterPositions.RosterPosition
8 |
9 | def get_by(clauses) do
10 | Repo.get_by(RosterPosition, clauses)
11 | end
12 |
13 | def list_all do
14 | RosterPosition
15 | |> RosterPosition.order_by_id()
16 | |> Repo.all()
17 | end
18 |
19 | def list_all_active do
20 | RosterPosition
21 | |> RosterPosition.all_active()
22 | |> RosterPosition.order_by_id()
23 | |> Repo.all()
24 | end
25 |
26 | def positions(%FantasyLeague{only_flex?: true, max_flex_spots: max_flex_spots}) do
27 | RosterPosition.flex_positions(max_flex_spots)
28 | end
29 |
30 | def positions(%FantasyLeague{id: fantasy_league_id, max_flex_spots: max_flex_spots}) do
31 | primary_positions = FantasyPlayers.list_sports_abbrevs(fantasy_league_id)
32 | primary_positions ++ RosterPosition.flex_positions(max_flex_spots)
33 | end
34 |
35 | def positions_for_draft(fantasy_league_id, championship_id) do
36 | RosterPosition
37 | |> RosterPosition.all_active()
38 | |> RosterPosition.all_draft_picks()
39 | |> RosterPosition.from_league(fantasy_league_id)
40 | |> RosterPosition.sport_from_champ(championship_id)
41 | |> RosterPosition.preload_assocs()
42 | |> Repo.all()
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/lib/ex338_web/controllers/waiver_admin_html.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.WaiverAdminHTML do
2 | use Ex338Web, :html
3 |
4 | def edit(assigns) do
5 | ~H"""
6 | <.two_col_form :let={f} for={@changeset} action={~p"/waiver_admin/#{@waiver}"}>
7 | <:title>
8 | Process Waiver
9 |
10 | <:description>
11 | {@waiver.fantasy_team.team_name}'s current waiver position is {@waiver.fantasy_team.waiver_position}.
12 |
13 |
14 |
15 | Add Fantasy Player:
16 | <%= if @waiver.add_fantasy_player do %>
17 | {@waiver.add_fantasy_player.player_name}
18 | <% else %>
19 | None
20 | <% end %>
21 |
22 |
23 |
24 | Drop Fantasy Player:
25 | <%= if @waiver.drop_fantasy_player do %>
26 | {@waiver.drop_fantasy_player.player_name}
27 | <% else %>
28 | None
29 | <% end %>
30 |
31 |
32 | <.input
33 | field={f[:status]}
34 | label="Select status for the waiver"
35 | type="select"
36 | options={Ex338.Waivers.Waiver.status_options()}
37 | />
38 | <:actions>
39 | <.submit_buttons back_route={~p"/fantasy_leagues/#{@fantasy_league}/waivers"} />
40 |
41 |
42 | """
43 | end
44 | end
45 |
--------------------------------------------------------------------------------
/lib/ex338_web/controllers/user_session_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.UserSessionController do
2 | use Ex338Web, :controller
3 |
4 | alias Ex338.Accounts
5 | alias Ex338Web.UserAuth
6 |
7 | def create(conn, %{"_action" => "registered"} = params) do
8 | create(conn, params, "Account created successfully!")
9 | end
10 |
11 | def create(conn, %{"_action" => "password_updated"} = params) do
12 | conn
13 | |> put_session(:user_return_to, ~p"/users/settings")
14 | |> create(params, "Password updated successfully!")
15 | end
16 |
17 | def create(conn, params) do
18 | create(conn, params, "Welcome back!")
19 | end
20 |
21 | defp create(conn, %{"user" => user_params}, info) do
22 | %{"email" => email, "password" => password} = user_params
23 |
24 | if user = Accounts.get_user_by_email_and_password(email, password) do
25 | conn
26 | |> put_flash(:info, info)
27 | |> UserAuth.log_in_user(user, user_params)
28 | else
29 | # In order to prevent user enumeration attacks, don't disclose whether the email is registered.
30 | conn
31 | |> put_flash(:error, "Invalid email or password")
32 | |> put_flash(:email, String.slice(email, 0, 160))
33 | |> redirect(to: ~p"/users/log_in")
34 | end
35 | end
36 |
37 | def delete(conn, _params) do
38 | conn
39 | |> put_flash(:info, "Logged out successfully.")
40 | |> UserAuth.log_out_user()
41 | end
42 | end
43 |
--------------------------------------------------------------------------------
/test/ex338_web/controllers/draft_pick_html_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.DraftPickHTMLTest do
2 | use Ex338Web.ConnCase, async: true
3 |
4 | alias Ex338Web.DraftPickHTML
5 |
6 | describe "current_picks/2" do
7 | test "returns last picks if no picks remaining" do
8 | amount = 10
9 | draft_picks = for n <- 1..16, do: %{draft_position: n, fantasy_player_id: n}
10 |
11 | results = DraftPickHTML.current_picks(draft_picks, amount)
12 |
13 | assert Enum.map(results, & &1.draft_position) == Enum.to_list(12..16)
14 | end
15 |
16 | test "returns first picks if no picks completed" do
17 | amount = 5
18 | draft_picks = for n <- 1..16, do: %{draft_position: n, fantasy_player_id: nil}
19 |
20 | results = DraftPickHTML.current_picks(draft_picks, amount)
21 |
22 | assert Enum.map(results, & &1.draft_position) == Enum.to_list(1..5)
23 | end
24 |
25 | test "returns last 5 and next 5 picks when amount 10 is provided" do
26 | amount = 10
27 | completed_draft_picks = for n <- 1..8, do: %{draft_position: n, fantasy_player_id: n}
28 | remaining_draft_picks = for n <- 9..16, do: %{draft_position: n, fantasy_player_id: nil}
29 |
30 | draft_picks = completed_draft_picks ++ remaining_draft_picks
31 |
32 | results = DraftPickHTML.current_picks(draft_picks, amount)
33 |
34 | assert Enum.map(results, & &1.draft_position) == Enum.to_list(4..13)
35 | end
36 | end
37 | end
38 |
--------------------------------------------------------------------------------
/lib/ex338/fantasy_team_authorizer.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.FantasyTeamAuthorizer do
2 | @moduledoc """
3 | A module to authorize access to actions for a Fantasy Team
4 | """
5 |
6 | alias Ex338.Accounts.User
7 | alias Ex338.FantasyTeams.FantasyTeam
8 | alias Ex338.InSeasonDraftPicks.InSeasonDraftPick
9 | alias Ex338.Repo
10 |
11 | def authorize(_action, %User{} = %{admin: true}, _schema) do
12 | :ok
13 | end
14 |
15 | def authorize(:edit_team, %User{} = user, %FantasyTeam{} = fantasy_team) do
16 | if owner?(user.id, fantasy_team) do
17 | :ok
18 | else
19 | {:error, :not_authorized}
20 | end
21 | end
22 |
23 | def authorize(
24 | :edit_in_season_draft_pick,
25 | %User{} = user,
26 | %InSeasonDraftPick{} = in_season_draft_pick
27 | ) do
28 | if owner?(user.id, in_season_draft_pick) do
29 | :ok
30 | else
31 | {:error, :not_authorized}
32 | end
33 | end
34 |
35 | defp owner?(user_id, %FantasyTeam{} = fantasy_team) do
36 | fantasy_team = Repo.preload(fantasy_team, :owners)
37 | owners = fantasy_team.owners
38 | Enum.any?(owners, &(&1.user_id == user_id))
39 | end
40 |
41 | defp owner?(user_id, %InSeasonDraftPick{} = draft_pick) do
42 | draft_pick = Repo.preload(draft_pick, draft_pick_asset: [fantasy_team: :owners])
43 | owners = draft_pick.draft_pick_asset.fantasy_team.owners
44 | Enum.any?(owners, &(&1.user_id == user_id))
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/priv/repo/csv_seed_data/fantasy_teams.csv:
--------------------------------------------------------------------------------
1 | Team Name,Waiver Position,Dues Paid,Winnings Received,Fantasy League Id
2 | Cougars,14,0,0,1
3 | Madd Dogs,10,0,0,1
4 | Sharks,13,0,0,1
5 | Jay Hawks,6,0,0,1
6 | Wild Cats,6,0,0,2
7 | Black Mambas,1,0,0,1
8 | Bengal Tigers,2,0,0,1
9 | Huskies,12,0,0,1
10 | Riveters,3,0,0,1
11 | Junior Mints,10,0,0,2
12 | She-Unit,5,0,0,1
13 | Black Widows,9,0,0,1
14 | Blitz Babes,7,0,0,2
15 | Bare Exposure,9,0,0,2
16 | Pink Cougars,7,0,0,1
17 | End Zone Divas,11,0,0,1
18 | Girl Power,11,0,0,2
19 | Victorious S,4,0,0,1
20 | Air Farce,1,0,0,2
21 | Jagermeister,13,0,0,2
22 | Hoosier Daddys,8,0,0,2
23 | Ocho Stinko,5,0,0,2
24 | No Punt Intended,8,0,0,1
25 | Loose Ends,2,0,0,2
26 | Jerry Seinfelds,4,0,0,2
27 | Deep Threat,3,0,0,2
28 | Pass Up,12,0,0,2
29 | Fumble This,14,0,0,2
30 | Cougars,1,0,0,3
31 | Madd Dogs,2,0,0,3
32 | Sharks,3,0,0,3
33 | Jay Hawks,4,0,0,3
34 | Wild Cats,5,0,0,3
35 | Black Mambas,6,0,0,3
36 | Bengal Tigers,7,0,0,3
37 | Huskies,8,0,0,3
38 | Riveters,9,0,0,3
39 | Junior Mints,10,0,0,3
40 | She-Unit,11,0,0,3
41 | Black Widows,12,0,0,3
42 | Blitz Babes,13,0,0,3
43 | Bare Exposure,14,0,0,3
44 | Pink Cougars,1,0,0,4
45 | End Zone Divas,2,0,0,4
46 | Girl Power,3,0,0,4
47 | Victorious S,4,0,0,4
48 | Air Farce,5,0,0,4
49 | Jagermeister,6,0,0,4
50 | Hoosier Daddys,7,0,0,4
51 | Ocho Stinko,8,0,0,4
52 | No Punt Intended,9,0,0,4
53 | Loose Ends,10,0,0,4
54 | Jerry Seinfelds,11,0,0,4
55 | Deep Threat,12,0,0,4
56 | Pass Up,13,0,0,4
57 | Fumble This,14,0,0,4
58 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20200518235225_remove_coherence_user_columns.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Repo.Migrations.RemoveCoherenceUserColumns do
2 | use Ecto.Migration
3 |
4 | def up do
5 | alter table(:users) do
6 | # rememberable
7 | remove(:remember_created_at)
8 | # recoverable
9 | remove(:reset_password_token)
10 | remove(:reset_password_sent_at)
11 | # lockable
12 | remove(:failed_attempts)
13 | remove(:locked_at)
14 | # trackable
15 | remove(:sign_in_count)
16 | remove(:current_sign_in_at)
17 | remove(:last_sign_in_at)
18 | remove(:current_sign_in_ip)
19 | remove(:last_sign_in_ip)
20 | # unlockable_with_token
21 | remove(:unlock_token)
22 | end
23 | end
24 |
25 | def down do
26 | alter table(:users) do
27 | # rememberable
28 | add(:remember_created_at, :utc_datetime)
29 | # recoverable
30 | add(:reset_password_token, :string)
31 | add(:reset_password_sent_at, :utc_datetime)
32 | # lockable
33 | add(:failed_attempts, :integer, default: 0)
34 | add(:locked_at, :utc_datetime)
35 | # trackable
36 | add(:sign_in_count, :integer, default: 0)
37 | add(:current_sign_in_at, :utc_datetime)
38 | add(:last_sign_in_at, :utc_datetime)
39 | add(:current_sign_in_ip, :string)
40 | add(:last_sign_in_ip, :string)
41 | # unlockable_with_token
42 | add(:unlock_token, :string)
43 | end
44 | end
45 | end
46 |
--------------------------------------------------------------------------------
/lib/ex338/abilities.ex:
--------------------------------------------------------------------------------
1 | defimpl Canada.Can, for: Ex338.Accounts.User do
2 | alias Ex338.Accounts.User
3 | alias Ex338.DraftPicks.DraftPick
4 | alias Ex338.FantasyTeams.FantasyTeam
5 | alias Ex338.InSeasonDraftPicks.InSeasonDraftPick
6 | alias Ex338.Waivers.Waiver
7 |
8 | def can?(%User{admin: true}, _, _), do: true
9 |
10 | def can?(%User{id: user_id}, action, %User{id: user_id}) when action in [:edit, :update] do
11 | true
12 | end
13 |
14 | def can?(%User{}, action, %User{}) when action in [:edit, :update] do
15 | false
16 | end
17 |
18 | def can?(%User{}, action, nil) when action in [:edit, :update] do
19 | false
20 | end
21 |
22 | def can?(%User{id: user_id}, action, model) when action in [:edit, :update, :create, :new] do
23 | owner?(user_id, model)
24 | end
25 |
26 | def can?(%User{id: _}, _, _), do: false
27 |
28 | defp owner?(user_id, %DraftPick{} = draft_pick) do
29 | owners = draft_pick.fantasy_team.owners
30 | Enum.any?(owners, &(&1.user_id == user_id))
31 | end
32 |
33 | defp owner?(user_id, %FantasyTeam{owners: owners}) do
34 | Enum.any?(owners, &(&1.user_id == user_id))
35 | end
36 |
37 | defp owner?(user_id, %Waiver{} = waiver) do
38 | owners = waiver.fantasy_team.owners
39 | Enum.any?(owners, &(&1.user_id == user_id))
40 | end
41 |
42 | defp owner?(user_id, %InSeasonDraftPick{} = draft_pick) do
43 | owners = draft_pick.draft_pick_asset.fantasy_team.owners
44 | Enum.any?(owners, &(&1.user_id == user_id))
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/lib/ex338_web/controllers/user_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.UserController do
2 | use Ex338Web, :controller
3 |
4 | import Canary.Plugs
5 |
6 | alias Ex338.Accounts
7 | alias Ex338.Accounts.User
8 | alias Ex338Web.Authorization
9 |
10 | plug(
11 | :load_and_authorize_resource,
12 | model: User,
13 | only: [:edit, :update],
14 | preload: [owners: :fantasy_team],
15 | unauthorized_handler: {Authorization, :handle_unauthorized}
16 | )
17 |
18 | def edit(conn, %{"id" => _id}) do
19 | user = conn.assigns.user
20 |
21 | render(
22 | conn,
23 | :edit,
24 | changeset: User.user_changeset(user),
25 | page_title: "338 Challenge",
26 | user: user
27 | )
28 | end
29 |
30 | def show(conn, %{"id" => id}) do
31 | user = Accounts.get_user!(id)
32 |
33 | render(
34 | conn,
35 | :show,
36 | user: user,
37 | page_title: "338 Challenge"
38 | )
39 | end
40 |
41 | def update(conn, %{"id" => id, "user" => params}) do
42 | user = Accounts.get_user!(id)
43 |
44 | case Accounts.update_user(user, params) do
45 | {:ok, user} ->
46 | conn
47 | |> put_flash(:info, "User info updated successfully.")
48 | |> redirect(to: ~p"/users/#{user}")
49 |
50 | {:error, changeset} ->
51 | render(
52 | conn,
53 | :edit,
54 | user: user,
55 | page_title: "338 Challenge",
56 | changeset: changeset
57 | )
58 | end
59 | end
60 | end
61 |
--------------------------------------------------------------------------------
/lib/ex338_web/notifiers/commish_notifier.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.CommishNotifier do
2 | @moduledoc false
3 |
4 | alias Ex338.Accounts.User
5 | alias Ex338.FantasyTeams
6 | alias Ex338.Repo
7 | alias Ex338Web.Mailer
8 | alias Ex338Web.NotifierTemplate
9 |
10 | def send_email_to_leagues(leagues, subject, message) do
11 | owners = FantasyTeams.get_leagues_email_addresses(leagues)
12 | admins = Repo.all(User.admin_emails())
13 | recipients = unique_recipients(owners, admins)
14 | default_admin = Mailer.default_from_name_and_email()
15 |
16 | email_info = %{
17 | cc: default_admin,
18 | from: default_admin,
19 | subject: subject,
20 | message: message
21 | }
22 |
23 | recipients
24 | |> batch_by_aws_max_recipients()
25 | |> Enum.map(fn recipients ->
26 | email_info
27 | |> Map.put(:bcc, recipients)
28 | |> NotifierTemplate.plain_text()
29 | |> Mailer.deliver()
30 | |> Mailer.handle_delivery()
31 | end)
32 | |> parse_results()
33 | end
34 |
35 | def unique_recipients(owners, admins) do
36 | Enum.uniq(owners ++ admins)
37 | end
38 |
39 | defp batch_by_aws_max_recipients(recipients) do
40 | Enum.chunk_every(recipients, 40)
41 | end
42 |
43 | defp parse_results(results) do
44 | Enum.reduce_while(results, {:ok, "commish emails sent"}, &parse_result/2)
45 | end
46 |
47 | defp parse_result({:ok, _result}, success_message) do
48 | {:cont, success_message}
49 | end
50 |
51 | defp parse_result({:error, _message} = error, _success_message) do
52 | {:halt, error}
53 | end
54 | end
55 |
--------------------------------------------------------------------------------
/lib/ex338/fantasy_teams/owner.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.FantasyTeams.Owner do
2 | @moduledoc false
3 | use Ecto.Schema
4 |
5 | import Ecto.Changeset
6 | import Ecto.Query, warn: false
7 |
8 | schema "owners" do
9 | belongs_to(:fantasy_team, Ex338.FantasyTeams.FantasyTeam)
10 | belongs_to(:user, Ex338.Accounts.User)
11 | field(:rules, OwnerRulesEnum, default: "unaccepted")
12 |
13 | timestamps()
14 | end
15 |
16 | @doc """
17 | Builds a changeset based on the `struct` and `params`.
18 | """
19 | def changeset(owner, params \\ %{}) do
20 | owner
21 | |> cast(params, [:fantasy_team_id, :user_id, :rules])
22 | |> validate_required([:fantasy_team_id, :user_id])
23 | |> foreign_key_constraint(:user_id)
24 | |> foreign_key_constraint(:fantasy_team_id)
25 | end
26 |
27 | def by_league(query, league_id) do
28 | from(
29 | o in query,
30 | join: f in assoc(o, :fantasy_team),
31 | where: f.fantasy_league_id == ^league_id,
32 | order_by: [asc: f.team_name]
33 | )
34 | end
35 |
36 | def by_team(query, team_id) do
37 | from(
38 | o in query,
39 | where: o.fantasy_team_id == ^team_id
40 | )
41 | end
42 |
43 | def email_recipients_for_league(query, league_id) do
44 | query
45 | |> by_league(league_id)
46 | |> join(:inner, [o], u in assoc(o, :user))
47 | |> select([o, f, u], {u.name, u.email})
48 | end
49 |
50 | def email_recipients_for_team(query, team_id) do
51 | query
52 | |> by_team(team_id)
53 | |> join(:inner, [o], u in assoc(o, :user))
54 | |> select([o, u], {u.name, u.email})
55 | end
56 | end
57 |
--------------------------------------------------------------------------------
/priv/repo/annual_league_setup/data/fantasy_teams.csv:
--------------------------------------------------------------------------------
1 | Projected ID,Fantasy Team Name,Waiver Position,Winnings Adj,Dues Paid,Winnings Received,Commish Notes,Fantasy League Id
2 | 68,Brown,1,0,0,0,,8
3 | 69,The Consortium,1,0,0,0,"PayPal Mara, swin cash",8
4 | 70,Kintz/Mori,1,0,0,0,"split 50/50, paypal",9
5 | 71,Axel,1,0,0,0,"split payments 75% to Nana, 25% to Ax, paypal",8
6 | 72,BD,1,0,0,0,,9
7 | 73,Bartch,1,0,0,0,venmo,8
8 | 74,Wilson,1,0,0,0,venmo to Tim,8
9 | 75,Miller/Wernz,1,0,0,0,paypal,8
10 | 76,FloPow,1,0,0,0,paypal,8
11 | 77,G-Brew,1,0,0,0,paypal,9
12 | 78,Davie/Paul,1,0,0,0,,8
13 | 79,Bro/Heli,1,0,0,0,,10
14 | 80,Jake,1,0,0,0,,9
15 | 81,Zach,1,0,0,0,Venmo,9
16 | 82,Vondy/Clark,1,0,0,0,paypal to Vondy,8
17 | 83,Adam/Mike,1,0,0,0,venmo adam,9
18 | 84,Evan,1,0,0,0,venmo,8
19 | 85,Hughes,1,0,0,0,pay via Venmo,9
20 | 86,Sister-Sister,1,0,0,0,paypal,9
21 | 87,Murphy's Law,1,0,0,0,Paypal,9
22 | 88,Tim,1,0,0,0,PayPal,8
23 | 89,Mike,1,0,0,0,paypal BSH,9
24 | 90,Riss/Ehrman,1,0,0,0,,9
25 | 91,Bailey,1,0,0,0,paypal,8
26 | 92,Nelson,1,0,0,0,Venmo,10
27 | 93,Teeter,1,0,0,0,paypal,10
28 | 94,Mick/Jason,1,0,0,0,paypal to Mick,9
29 | 95,Tom,1,0,0,0,PayPal,8
30 | 96,Danger 338,1,0,0,0,venmo,9
31 | 97,THE LIFE OF JASO,1,0,0,0,paypal to thecaseymclain@gmail.com,9
32 | 98,Tom/Josh,1,0,0,0,PayPal to Tom,9
33 | 99,Christian/Zach,1,0,0,0,PayPal Zach,10
34 | 100,Scotchy-Scotch,1,0,0,0,paypal,9
35 | 101,Cody,1,0,0,0,,10
36 | 102,Ryan/Aaron,1,0,0,0,,10
37 | 103,Mick/Jackson,1,0,0,0,,10
38 | 104,Ross,1,0,0,0,,10
39 | 105,Gavin/Sahil,1,0,0,0,,10
40 | 106,Zach Taylor,1,0,0,0,,10
41 | 107,Jim,1,0,0,0,,10
42 | 108,Marcus,1,0,0,0,,10
43 | 109,Matthius/Casey,1,0,0,0,,10
44 |
--------------------------------------------------------------------------------
/test/ex338/validate_helpers_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.ValidateHelpersTest do
2 | use Ex338.DataCase, async: true
3 |
4 | alias Ex338.ValidateHelpers
5 |
6 | describe "slot_available/2" do
7 | test "returns false if too many flex spots in use" do
8 | max_flex_slots = 3
9 | tm = insert(:fantasy_team)
10 | regular_slots = insert_list(4, :roster_position, fantasy_team: tm)
11 |
12 | flex_sport = List.first(regular_slots).fantasy_player.sports_league
13 |
14 | plyrs = insert_list(4, :fantasy_player, sports_league: flex_sport)
15 |
16 | flex_slots =
17 | for plyr <- plyrs do
18 | build(:roster_position, fantasy_team: tm, fantasy_player: plyr)
19 | end
20 |
21 | all_slots = regular_slots ++ flex_slots
22 |
23 | result = ValidateHelpers.slot_available?(all_slots, max_flex_slots)
24 |
25 | assert result == false
26 | end
27 |
28 | test "returns true if flex slot is available" do
29 | max_flex_slots = 3
30 | tm = insert(:fantasy_team)
31 | regular_slots = insert_list(4, :roster_position, fantasy_team: tm)
32 |
33 | flex_sport = List.first(regular_slots).fantasy_player.sports_league
34 |
35 | plyrs = insert_list(3, :fantasy_player, sports_league: flex_sport)
36 |
37 | flex_slots =
38 | for plyr <- plyrs do
39 | build(:roster_position, fantasy_team: tm, fantasy_player: plyr)
40 | end
41 |
42 | all_slots = regular_slots ++ flex_slots
43 |
44 | result = ValidateHelpers.slot_available?(all_slots, max_flex_slots)
45 |
46 | assert result == true
47 | end
48 | end
49 | end
50 |
--------------------------------------------------------------------------------
/test/ex338/trades/trade_vote_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Trades.TradeVoteTest do
2 | use Ex338.DataCase, async: true
3 |
4 | alias Ex338.Trades.TradeVote
5 |
6 | describe "changeset/2" do
7 | @valid_attrs %{
8 | trade_id: 1,
9 | fantasy_team_id: 2,
10 | user_id: 3,
11 | approve: false
12 | }
13 | test "valid with required attributes" do
14 | changeset = TradeVote.changeset(%TradeVote{}, @valid_attrs)
15 | assert changeset.valid?
16 | end
17 |
18 | @invalid_attrs %{}
19 | test "invalid without required attributes" do
20 | changeset = TradeVote.changeset(%TradeVote{}, @invalid_attrs)
21 | refute changeset.valid?
22 | end
23 |
24 | test "invalid if team already voted" do
25 | trade = insert(:trade)
26 | team = insert(:fantasy_team)
27 | user = insert(:user)
28 | other_user = insert(:user)
29 | insert(:trade_vote, user: user, trade: trade, fantasy_team: team)
30 |
31 | attrs = %{
32 | trade_id: trade.id,
33 | fantasy_team_id: team.id,
34 | user_id: other_user.id,
35 | approve: false
36 | }
37 |
38 | changeset = TradeVote.changeset(%TradeVote{}, attrs)
39 | {:error, changeset} = Repo.insert(changeset)
40 |
41 | refute changeset.valid?
42 |
43 | assert changeset.errors == [
44 | trade:
45 | {"Team has already voted",
46 | [
47 | constraint: :unique,
48 | constraint_name: "trade_votes_trade_id_fantasy_team_id_index"
49 | ]}
50 | ]
51 | end
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/lib/ex338/championships/championship_slot.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Championships.ChampionshipSlot do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 |
6 | import Ecto.Changeset
7 | import Ecto.Query, warn: false
8 |
9 | alias Ex338.Championships.ChampionshipResult
10 |
11 | schema "championship_slots" do
12 | field(:slot, :integer)
13 | belongs_to(:roster_position, Ex338.RosterPositions.RosterPosition)
14 | belongs_to(:championship, Ex338.Championships.Championship)
15 |
16 | timestamps()
17 | end
18 |
19 | @doc """
20 | Builds a changeset based on the `struct` and `params`.
21 | """
22 | def changeset(slot_struct, params \\ %{}) do
23 | slot_struct
24 | |> cast(params, [:slot, :roster_position_id, :championship_id])
25 | |> validate_required([:slot])
26 | end
27 |
28 | def preload_assocs_by_league(query, league_id) do
29 | from(
30 | s in query,
31 | join: r in assoc(s, :roster_position),
32 | join: f in assoc(r, :fantasy_team),
33 | join: p in assoc(r, :fantasy_player),
34 | left_join: cr in ChampionshipResult,
35 | on: cr.fantasy_player_id == p.id and s.championship_id == cr.championship_id,
36 | join: c in assoc(s, :championship),
37 | where: f.fantasy_league_id == ^league_id,
38 | where: r.active_at < c.championship_at,
39 | where: r.released_at > c.championship_at or is_nil(r.released_at),
40 | order_by: [f.team_name, s.slot],
41 | preload: [roster_position: :fantasy_team],
42 | preload: [roster_position: {r, fantasy_player: {p, championship_results: cr}}],
43 | preload: [:championship]
44 | )
45 | end
46 | end
47 |
--------------------------------------------------------------------------------
/lib/ex338/chats.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Chats do
2 | @moduledoc """
3 | The Chats context.
4 | """
5 |
6 | import Ecto.Query
7 |
8 | alias Ex338.Accounts.User
9 | alias Ex338.Chats.Chat
10 | alias Ex338.Chats.Message
11 | alias Ex338.Repo
12 |
13 | def subscribe(%Chat{} = chat, %User{}) do
14 | Phoenix.PubSub.subscribe(Ex338.PubSub, topic(chat))
15 | end
16 |
17 | def subscribe(_chat, nil), do: nil
18 |
19 | def create_chat(chat_params) do
20 | %Chat{}
21 | |> Chat.changeset(chat_params)
22 | |> Repo.insert()
23 | end
24 |
25 | def create_message(message_params) do
26 | %Message{}
27 | |> Message.changeset(message_params)
28 | |> Repo.insert()
29 | |> case do
30 | {:ok, message} ->
31 | message = Repo.preload(message, user: [owners: :fantasy_team])
32 | broadcast(message, %Ex338.Events.MessageCreated{message: message})
33 | {:ok, message}
34 |
35 | other ->
36 | other
37 | end
38 | end
39 |
40 | def change_message(%Message{} = message, attrs \\ %{}) do
41 | Message.changeset(message, attrs)
42 | end
43 |
44 | def list_chats do
45 | Repo.all(Chat)
46 | end
47 |
48 | def get_chat(chat_id) do
49 | query =
50 | from c in Chat,
51 | where: c.id == ^chat_id,
52 | preload: [messages: :user]
53 |
54 | Repo.one(query)
55 | end
56 |
57 | defp broadcast(%Message{} = message, event) do
58 | Phoenix.PubSub.broadcast(Ex338.PubSub, topic(message), {__MODULE__, event})
59 | end
60 |
61 | def topic(%Message{} = message), do: "chat:#{message.chat_id}"
62 | def topic(%Chat{} = chat), do: "chat:#{chat.id}"
63 | end
64 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # The directory Mix will write compiled artifacts to.
2 | /_build/
3 |
4 | # If you run "mix test --cover", coverage assets end up here.
5 | /cover/
6 |
7 | # The directory Mix downloads your dependencies sources to.
8 | /deps/
9 |
10 | # Where 3rd-party dependencies like ExDoc output generated docs.
11 | /doc/
12 |
13 | # Ignore .fetch files in case you like to edit your project deps locally.
14 | /.fetch
15 |
16 | # If the VM crashes, it generates a dump, let's ignore it too.
17 | erl_crash.dump
18 |
19 | # Also ignore archive artifacts (built via "mix archive.build").
20 | *.ez
21 |
22 | # Temporary files, for example, from tests.
23 | /tmp/
24 |
25 | # Ignore package tarball (built via "mix hex.build").
26 | ex338-*.tar
27 |
28 | # Ignore assets that are produced by build tools.
29 | /priv/static/assets/
30 |
31 | # Ignore digested assets cache.
32 | /priv/static/cache_manifest.json
33 |
34 | # In case you use Node.js/npm, you want to ignore these.
35 | npm-debug.log
36 | /assets/node_modules/
37 |
38 | # App artifacts
39 | /db
40 |
41 | # Since we are building assets from assets/,
42 | # we ignore priv/static. You may want to comment
43 | # this depending on your deployment strategy.
44 | # /priv/static/
45 |
46 | # The config/prod.secret.exs file by default contains sensitive
47 | # data and you should not commit it into version control.
48 | #
49 | # Alternatively, you may comment the line below and commit the
50 | # secrets file as long as you replace its contents by environment
51 | # variables.
52 | /config/prod.secret.exs
53 |
54 | .DS_Store
55 |
56 | tags
57 |
58 | dump.rdb
59 |
60 | .projections.json
61 |
62 | logfile
63 |
64 | .lexical
65 |
--------------------------------------------------------------------------------
/lib/ex338/uploader.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Uploader do
2 | @moduledoc false
3 |
4 | alias Ecto.Multi
5 | alias Ex338.Repo
6 |
7 | @table_options [
8 | "Championships.Championship",
9 | "Championships.ChampionshipResult",
10 | "DraftPicks.DraftPick",
11 | "FantasyLeagues.FantasyLeague",
12 | "FantasyPlayers.FantasyPlayer",
13 | "FantasyTeams.FantasyTeam",
14 | "InSeasonDraftPicks.InSeasonDraftPick",
15 | "FantasyLeagues.LeagueSport",
16 | "FantasyTeams.Owner",
17 | "RosterPositions.RosterPosition",
18 | "FantasyPlayers.SportsLeague"
19 | ]
20 |
21 | def build_inserts_from_rows(rows, table) do
22 | module = Module.safe_concat([Ex338, table])
23 | {multi, _num_rows} = Enum.reduce(rows, {Multi.new(), 1}, &build_insert(&1, &2, module))
24 | multi
25 | end
26 |
27 | def insert_from_csv(file_path, table) do
28 | file_path
29 | |> File.stream!()
30 | |> format_text()
31 | |> CSV.decode!(headers: true)
32 | |> build_inserts_from_rows(table)
33 | |> Repo.transaction()
34 | end
35 |
36 | def table_options, do: @table_options
37 |
38 | ## Helpers
39 |
40 | ## build_inserts_from_rows
41 |
42 | defp build_insert(row, {multi, num}, module) do
43 | changeset =
44 | module
45 | |> struct()
46 | |> module.changeset(row)
47 |
48 | multi = Multi.insert(multi, {module, num}, changeset)
49 |
50 | {multi, num + 1}
51 | end
52 |
53 | ## insert_from_csv
54 |
55 | defp format_text(file_stream) do
56 | file_stream
57 | |> Stream.map(&String.replace(&1, "FALSE", "false"))
58 | |> Stream.map(&String.replace(&1, "TRUE", "true"))
59 | end
60 | end
61 |
--------------------------------------------------------------------------------
/lib/ex338/application.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Application do
2 | @moduledoc false
3 |
4 | use Application
5 |
6 | # See http://elixir-lang.org/docs/stable/elixir/Application.html
7 | # for more information on OTP Applications
8 | def start(_type, _args) do
9 | pubsub_options =
10 | case Mix.env() do
11 | :test ->
12 | [name: Ex338.PubSub]
13 |
14 | _ ->
15 | [
16 | name: Ex338.PubSub,
17 | adapter: Phoenix.PubSub.Redis,
18 | url: System.get_env("REDIS_URL") || "redis://localhost:6379",
19 | node_name: System.get_env("NODE") || "name"
20 | ]
21 | end
22 |
23 | # Define workers and child supervisors to be supervised
24 | children = [
25 | # Start the Ecto repository
26 | Ex338.Repo,
27 | {Phoenix.PubSub, pubsub_options},
28 | Ex338Web.Telemetry,
29 | Ex338Web.Presence,
30 | # Start the endpoint when the application starts
31 | Ex338Web.Endpoint,
32 | {Oban, Application.fetch_env!(:ex338, Oban)}
33 | # Start a worker by calling: HelloFly.Worker.start_link(arg)
34 | # {HelloFly.Worker, arg}
35 | ]
36 |
37 | # See http://elixir-lang.org/docs/stable/elixir/Supervisor.html
38 | # for other strategies and supported options
39 | opts = [strategy: :one_for_one, name: Ex338.Supervisor]
40 | Supervisor.start_link(children, opts)
41 | end
42 |
43 | # Tell Phoenix to update the endpoint configuration
44 | # whenever the application is updated.
45 | def config_change(changed, _new, removed) do
46 | Ex338Web.Endpoint.config_change(changed, removed)
47 | :ok
48 | end
49 | end
50 |
--------------------------------------------------------------------------------
/lib/ex338/fantasy_players/sports_league.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.FantasyPlayers.SportsLeague do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 |
6 | import Ecto.Changeset
7 | import Ecto.Query, warn: false
8 |
9 | alias Ex338.Championships.Championship
10 |
11 | schema "sports_leagues" do
12 | field(:league_name, :string)
13 | field(:abbrev, :string)
14 | field(:hide_waivers, :boolean)
15 | has_many(:fantasy_players, Ex338.FantasyPlayers.FantasyPlayer)
16 | has_many(:championships, Ex338.Championships.Championship)
17 | has_many(:league_sports, Ex338.FantasyLeagues.LeagueSport)
18 |
19 | timestamps()
20 | end
21 |
22 | def abbrev_a_to_z(query) do
23 | from(s in query, order_by: s.abbrev)
24 | end
25 |
26 | def alphabetical(query) do
27 | from(s in query, order_by: s.league_name)
28 | end
29 |
30 | def changeset(struct, params \\ %{}) do
31 | struct
32 | |> cast(params, [:league_name, :abbrev, :hide_waivers])
33 | |> validate_required([:league_name, :abbrev])
34 | end
35 |
36 | def for_league(query, fantasy_league_id) do
37 | from(
38 | s in query,
39 | inner_join: ls in assoc(s, :league_sports),
40 | where: ls.fantasy_league_id == ^fantasy_league_id
41 | )
42 | end
43 |
44 | def preload_league_overall_championships(query, fantasy_league_id) do
45 | championships =
46 | Championship
47 | |> Championship.overall_championships()
48 | |> Championship.all_for_league(fantasy_league_id)
49 |
50 | from(s in query, preload: [championships: ^championships])
51 | end
52 |
53 | def select_abbrev(query) do
54 | from(s in query, select: s.abbrev)
55 | end
56 | end
57 |
--------------------------------------------------------------------------------
/lib/ex338/icalendar.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.ICalendar do
2 | @moduledoc false
3 |
4 | defmodule Event do
5 | @moduledoc false
6 | defstruct summary: nil,
7 | dtstart: nil,
8 | dtend: nil,
9 | dtstamp: nil,
10 | description: nil,
11 | uid: nil
12 | end
13 |
14 | def to_ics(events) when is_list(events) do
15 | events = Enum.map(events, &to_ics/1)
16 |
17 | calendar =
18 | """
19 | BEGIN:VCALENDAR
20 | CALSCALE:GREGORIAN
21 | VERSION:2.0
22 | PRODID:-//Ex338 ICalendar//EN
23 | #{events}END:VCALENDAR
24 | """
25 |
26 | String.replace(calendar, "\n", "\r\n")
27 | end
28 |
29 | def to_ics(event) do
30 | contents = to_kvs(event)
31 |
32 | """
33 | BEGIN:VEVENT
34 | #{contents}END:VEVENT
35 | """
36 | end
37 |
38 | defp to_kvs(event) do
39 | event
40 | |> Map.from_struct()
41 | |> Enum.map(&to_kv/1)
42 | |> List.flatten()
43 | |> Enum.sort()
44 | |> Enum.join()
45 | end
46 |
47 | defp to_kv({key, value}) do
48 | name =
49 | key
50 | |> to_string()
51 | |> String.upcase()
52 |
53 | build(name, value)
54 | end
55 |
56 | def build(_key, nil) do
57 | ""
58 | end
59 |
60 | def build(key, %Date{} = date) do
61 | "#{key}:#{Date.to_iso8601(date, :basic)}\n"
62 | end
63 |
64 | def build(key, %DateTime{} = datetime) do
65 | datetime =
66 | datetime
67 | |> DateTime.truncate(:second)
68 | |> DateTime.to_iso8601(:basic)
69 |
70 | "#{key}:#{datetime}\n"
71 | end
72 |
73 | def build(key, value) do
74 | "#{key}:#{value}\n"
75 | end
76 | end
77 |
--------------------------------------------------------------------------------
/lib/ex338_web/live/user_invitation_live.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.UserInvitationLive do
2 | @moduledoc false
3 | use Ex338Web, :live_view
4 |
5 | alias Ex338.Accounts
6 |
7 | def render(assigns) do
8 | ~H"""
9 | <.padded_container>
10 |
11 | <.header class="text-center">
12 | Invite a new user
13 | <:subtitle>Email a registration link to a new user.
14 |
15 |
16 | <.simple_form for={@form} id="invitation_form" phx-submit="send_email" class="bg-gray-200!">
17 | <.input field={@form[:email]} type="email" placeholder="Email" required />
18 | <:actions>
19 | <.button phx-disable-with="Sending..." class="w-full">
20 | Send registration link
21 |
22 |
23 |
24 |
25 | <.link
26 | href={~p"/"}
27 | class="text-sm font-medium text-indigo-600 hover:text-indigo-500 focus:outline-hidden focus:underline transition ease-in-out duration-150"
28 | >
29 | Back
30 |
31 |
32 |
9 | <.header class="text-center">
10 | Sign in to The 338 Challenge
11 | <:subtitle>
12 |
13 |
14 | <.simple_form
15 | for={@form}
16 | id="login_form"
17 | action={~p"/users/log_in"}
18 | phx-update="ignore"
19 | class="bg-gray-200! max-w-md m-auto"
20 | >
21 | <.input field={@form[:email]} type="email" label="Email" required />
22 | <.input field={@form[:password]} type="password" label="Password" required />
23 |
24 | <:actions>
25 | <.input field={@form[:remember_me]} type="checkbox" label="Keep me logged in" />
26 | <.link
27 | href={~p"/users/reset_password"}
28 | class="text-sm font-medium text-indigo-600 hover:text-indigo-500 focus:outline-hidden focus:underline transition ease-in-out duration-150"
29 | >
30 | Forgot your password?
31 |
32 |
33 | <:actions>
34 | <.button phx-disable-with="Signing in..." class="w-full">
35 | Sign in →
36 |
37 |
38 |
39 |
40 |
41 | """
42 | end
43 |
44 | def mount(_params, _session, socket) do
45 | email = Phoenix.Flash.get(socket.assigns.flash, :email)
46 | form = to_form(%{"email" => email}, as: "user")
47 | {:ok, assign(socket, form: form), temporary_assigns: [form: form]}
48 | end
49 | end
50 |
--------------------------------------------------------------------------------
/test/ex338/trades/admin_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.Trades.AdminTest do
2 | use Ex338.DataCase, async: true
3 |
4 | alias Ecto.Multi
5 | alias Ex338.DraftPicks
6 | alias Ex338.RosterPositions.RosterPosition
7 | alias Ex338.Trades.Admin
8 | alias Ex338.Trades.Trade
9 | alias Ex338.Trades.TradeLineItem
10 |
11 | @trade %Trade{
12 | status: "Pending",
13 | trade_line_items: [
14 | %TradeLineItem{
15 | losing_team_id: 1,
16 | fantasy_player_id: 2,
17 | gaining_team_id: 3
18 | },
19 | %TradeLineItem{
20 | losing_team_id: 1,
21 | future_pick_id: 4,
22 | gaining_team_id: 3,
23 | future_pick: %DraftPicks.FuturePick{
24 | id: 4,
25 | round: 1,
26 | current_team_id: 1,
27 | original_team_id: 1
28 | }
29 | }
30 | ]
31 | }
32 |
33 | @positions [
34 | %RosterPosition{
35 | id: 4,
36 | fantasy_team_id: 1,
37 | fantasy_player_id: 2,
38 | status: "active"
39 | }
40 | ]
41 |
42 | describe "process_approved_trade/3" do
43 | test "with Approved status, returns a multi with valid changeset" do
44 | params = %{"status" => "Approved"}
45 |
46 | multi = Admin.process_approved_trade(@trade, params, @positions)
47 |
48 | assert [
49 | {:trade, {:update, trade_changeset, []}},
50 | {:losing_position_4, {:update, los_pos_changeset, []}},
51 | {:gaining_position_2, {:insert, gain_pos_changeset, []}},
52 | {:future_pick_4, {:update, future_pick_changeset, []}}
53 | ] = Multi.to_list(multi)
54 |
55 | assert trade_changeset.valid?
56 | assert los_pos_changeset.valid?
57 | assert gain_pos_changeset.valid?
58 | assert future_pick_changeset.valid?
59 | end
60 | end
61 | end
62 |
--------------------------------------------------------------------------------
/lib/ex338/injured_reserves/injured_reserve.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338.InjuredReserves.InjuredReserve do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 |
6 | import Ecto.Changeset
7 | import Ecto.Query, warn: false
8 |
9 | alias Ex338.FantasyPlayers.FantasyPlayer
10 | alias Ex338.InjuredReserves.InjuredReserve
11 |
12 | schema "injured_reserves" do
13 | field(:status, InjuredReserveStatusEnum, default: "submitted")
14 | belongs_to(:fantasy_team, Ex338.FantasyTeams.FantasyTeam)
15 | belongs_to(:injured_player, FantasyPlayer)
16 | belongs_to(:replacement_player, FantasyPlayer)
17 |
18 | timestamps()
19 | end
20 |
21 | @doc """
22 | Builds a changeset based on the `struct` and `params`.
23 | """
24 | def changeset(%InjuredReserve{} = injured_reserve, params \\ %{}) do
25 | injured_reserve
26 | |> cast(params, [
27 | :status,
28 | :fantasy_team_id,
29 | :injured_player_id,
30 | :replacement_player_id
31 | ])
32 | |> validate_required([:fantasy_team_id, :injured_player_id, :replacement_player_id, :status])
33 | |> validate_inclusion(:status, InjuredReserveStatusEnum.__valid_values__())
34 | end
35 |
36 | def by_league(query, league_id) do
37 | from(
38 | i in query,
39 | join: f in assoc(i, :fantasy_team),
40 | where: f.fantasy_league_id == ^league_id,
41 | order_by: [desc: i.inserted_at]
42 | )
43 | end
44 |
45 | def by_status(query, statuses) when is_list(statuses) do
46 | from(
47 | i in query,
48 | where: i.status in ^statuses
49 | )
50 | end
51 |
52 | def preload_assocs(query) do
53 | from(
54 | i in query,
55 | preload: [
56 | [fantasy_team: [:owners, :fantasy_league]],
57 | [injured_player: :sports_league],
58 | [replacement_player: :sports_league]
59 | ]
60 | )
61 | end
62 | end
63 |
--------------------------------------------------------------------------------
/lib/ex338_web/telemetry.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.Telemetry do
2 | @moduledoc false
3 | use Supervisor
4 |
5 | import Telemetry.Metrics
6 |
7 | def start_link(arg) do
8 | Supervisor.start_link(__MODULE__, arg, name: __MODULE__)
9 | end
10 |
11 | @impl true
12 | def init(_arg) do
13 | children = [
14 | # Telemetry poller will execute the given period measurements
15 | # every 10_000ms. Learn more here: https://hexdocs.pm/telemetry_metrics
16 | {:telemetry_poller, measurements: periodic_measurements(), period: 10_000}
17 | # Add reporters as children of your supervision tree.
18 | # {Telemetry.Metrics.ConsoleReporter, metrics: metrics()}
19 | ]
20 |
21 | Supervisor.init(children, strategy: :one_for_one)
22 | end
23 |
24 | def metrics do
25 | [
26 | # Phoenix Metrics
27 | summary("phoenix.endpoint.stop.duration",
28 | unit: {:native, :millisecond}
29 | ),
30 | summary("phoenix.router_dispatch.stop.duration",
31 | tags: [:route],
32 | unit: {:native, :millisecond}
33 | ),
34 |
35 | # Database Time Metrics
36 | summary("ex338.repo.query.total_time", unit: {:native, :millisecond}),
37 | summary("ex338.repo.query.decode_time", unit: {:native, :millisecond}),
38 | summary("ex338.repo.query.query_time", unit: {:native, :millisecond}),
39 | summary("ex338.repo.query.queue_time", unit: {:native, :millisecond}),
40 | summary("ex338.repo.query.idle_time", unit: {:native, :millisecond}),
41 |
42 | # VM Metrics
43 | summary("vm.memory.total", unit: {:byte, :kilobyte}),
44 | summary("vm.total_run_queue_lengths.total"),
45 | summary("vm.total_run_queue_lengths.cpu"),
46 | summary("vm.total_run_queue_lengths.io")
47 | ]
48 | end
49 |
50 | defp periodic_measurements do
51 | []
52 | end
53 | end
54 |
--------------------------------------------------------------------------------
/lib/ex338_web/live/user_confirmation_instructions_live.ex:
--------------------------------------------------------------------------------
1 | defmodule Ex338Web.UserConfirmationInstructionsLive do
2 | @moduledoc false
3 | use Ex338Web, :live_view
4 |
5 | alias Ex338.Accounts
6 |
7 | def render(assigns) do
8 | ~H"""
9 | <.padded_container>
10 |
11 | <.header class="text-center">
12 | No confirmation instructions received?
13 | <:subtitle>We'll send a new confirmation link to your inbox
14 |
15 |
16 | <.simple_form for={@form} id="resend_confirmation_form" phx-submit="send_instructions">
17 | <.input field={@form[:email]} type="email" placeholder="Email" required />
18 | <:actions>
19 | <.button phx-disable-with="Sending..." class="w-full">
20 | Resend confirmation instructions
21 |
22 |
23 |
24 |
25 |
26 | <.link href={~p"/users/register"}>Register
27 | | <.link href={~p"/users/log_in"}>Log in
28 |
29 |
47 | <.live_component
48 | module={Ex338Web.FantasyTeamDraftQueuesLive.NewFormComponent}
49 | id={:new}
50 | fantasy_team={@fantasy_team}
51 | draft_queue={@new_draft_queue}
52 | />
53 | <.live_component
54 | module={Ex338Web.FantasyTeamDraftQueuesLive.EditFormComponent}
55 | id={@fantasy_team.id}
56 | fantasy_team={@fantasy_team}
57 | />
58 |
59 | """
60 | end
61 | end
62 |
--------------------------------------------------------------------------------
/test/ex338/accounts/user_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Ex338.UserTest do
2 | use Ex338.DataCase, async: true
3 |
4 | alias Ex338.Accounts.User
5 |
6 | describe "admin_emails/0" do
7 | test "returns all admin emails" do
8 | admin_a = insert_admin()
9 |
10 | query = User.admin_emails()
11 |
12 | assert Repo.all(query) == [{admin_a.name, admin_a.email}]
13 | end
14 | end
15 |
16 | describe "alphabetical/1" do
17 | test "returns users in alphabetical order by name" do
18 | insert(:user, name: "B")
19 | insert(:user, name: "A")
20 | insert(:user, name: "C")
21 |
22 | result =
23 | User
24 | |> User.alphabetical()
25 | |> Repo.all()
26 | |> Enum.map(& &1.name)
27 |
28 | assert result == ["A", "B", "C"]
29 | end
30 | end
31 |
32 | describe "preload_assocs/1" do
33 | test "preloads assocs for a user" do
34 | user = insert(:user)
35 | team = insert(:fantasy_team)
36 | insert(:owner, user: user, fantasy_team: team)
37 |
38 | %{owners: [owner_result]} =
39 | User
40 | |> User.preload_assocs()
41 | |> Repo.one()
42 |
43 | assert owner_result.fantasy_team.id == team.id
44 | end
45 | end
46 |
47 | describe "user_changeset/2" do
48 | @valid_attrs %{email: "axel@example.com"}
49 | test "changeset with valid attributes" do
50 | changeset = User.user_changeset(%User{name: "A", email: "j@me.com"}, @valid_attrs)
51 | assert changeset.valid?
52 | end
53 |
54 | @invalid_attrs %{email: "j"}
55 | test "changeset with invalid attributes" do
56 | changeset = User.user_changeset(%User{name: "A", email: "j@me.com"}, @invalid_attrs)
57 | refute changeset.valid?
58 | end
59 |
60 | @extra_attrs %{admin: true}
61 | test "doesn't allow updates to unauthorized fields" do
62 | changeset = User.user_changeset(%User{name: "A", email: "j@me.com"}, @extra_attrs)
63 | assert changeset.changes == %{}
64 | end
65 | end
66 | end
67 |
--------------------------------------------------------------------------------