The <%= @race.name %> starts on <%= date(assigns) %> at <%= time(assigns) %>.
5 | <% end %>
6 |
7 | Yes, the <%= @race.name %> is a Boston Qualifier.
10 | <% else %>
11 | No, the <%= @race.name %> is not a Boston Qualifier.
12 | <% end %>
13 |
--------------------------------------------------------------------------------
/assets/css/core/utilities/_position.scss:
--------------------------------------------------------------------------------
1 | //
2 | // Position
3 | // modifier classes to be applied on an abosolute positioned element
4 | // use it next to .position-absolute class
5 | //
6 |
7 | @each $size, $value in $spacers {
8 | .top-#{$size} {
9 | top: $value;
10 | }
11 | .right-#{$size} {
12 | right: $value;
13 | }
14 | .bottom-#{$size} {
15 | bottom: $value;
16 | }
17 | .left-#{$size} {
18 | left: $value;
19 | }
20 | }
21 |
22 | .center {
23 | left: 50%;
24 | transform: translateX(-50%);
25 | }
26 |
--------------------------------------------------------------------------------
/lib/squeeze_web/views/modal_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.ModalView do
2 | use SqueezeWeb, :view
3 | @moduledoc false
4 |
5 | def activity_types do
6 | [
7 | "Run",
8 | "Bike",
9 | "Swim",
10 | "Cross Training",
11 | "Walk",
12 | "Strength Training",
13 | "Workout",
14 | "Yoga"
15 | ]
16 | end
17 |
18 | def workout_types do
19 | [
20 | "Race": "race",
21 | "Long Run": "long_run",
22 | "Workout": "workout"
23 | ]
24 | end
25 | end
26 |
--------------------------------------------------------------------------------
/test/squeeze_web/plugs/auth_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.Plug.AuthTest do
2 | use SqueezeWeb.ConnCase
3 |
4 | alias SqueezeWeb.Plug.Auth
5 |
6 | test "gets authenticated user from session", %{conn: conn} do
7 | conn = conn
8 | |> call_auth_plug()
9 |
10 | assert assigned_current_user?(conn)
11 | end
12 |
13 | defp assigned_current_user?(conn) do
14 | assert conn.assigns[:current_user] != nil
15 | end
16 |
17 | defp call_auth_plug(conn) do
18 | Auth.call(conn, %{})
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/lib/squeeze_web/live/settings/namer_card_component.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.Settings.NamerCardComponent do
2 | use SqueezeWeb, :live_component
3 | @moduledoc false
4 |
5 | alias Squeeze.Accounts.UserPrefs
6 |
7 | def gender_opts do
8 | Ecto.Enum.mappings(UserPrefs, :gender)
9 | |> Enum.map(fn ({k, _}) -> {format_option(k), k} end)
10 | end
11 |
12 | defp format_option(opt) do
13 | opt
14 | |> Atom.to_string()
15 | |> String.replace("_", " ")
16 | |> String.capitalize()
17 | end
18 | end
19 |
--------------------------------------------------------------------------------
/test/factories/billing_plan_factory.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.BillingPlanFactory do
2 | @moduledoc false
3 |
4 | alias Faker.Lorem
5 | alias Squeeze.Billing.Plan
6 |
7 | defmacro __using__(_opts) do
8 | quote do
9 | def billing_plan_factory do
10 | %Plan{
11 | name: "Base Monthly Fee",
12 | amount: 1_000,
13 | provider_id: "plan_#{Lorem.characters(15)}",
14 | interval: "month",
15 | default: false
16 | }
17 | end
18 | end
19 | end
20 | end
21 |
--------------------------------------------------------------------------------
/test/squeeze/email_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.EmailTest do
2 | use Squeeze.DataCase
3 |
4 | alias Squeeze.Email
5 |
6 | import Squeeze.Factory
7 |
8 | test "welcome email" do
9 | user = insert(:user)
10 |
11 | email = Email.welcome_email(user)
12 |
13 | assert email.to == user.email
14 | assert email.from == {"The OpenPace Team", "team@openpace.co"}
15 | assert email.html_body =~ "Welcome to the OpenPace family!"
16 | assert email.text_body =~ "Welcome to the OpenPace family!"
17 | end
18 | end
19 |
--------------------------------------------------------------------------------
/assets/css/core/mixins/_modals.scss:
--------------------------------------------------------------------------------
1 | @mixin modal-variant($background) {
2 | .modal-title {
3 | color: color-yiq($background);
4 | }
5 |
6 | .modal-header,
7 | .modal-footer {
8 | border-color: rgba(color-yiq($background), .075);
9 | }
10 |
11 | .modal-content {
12 | background-color: $background;
13 | color: color-yiq($background);
14 |
15 | .heading {
16 | color: color-yiq($background);
17 | }
18 | }
19 |
20 | .close {
21 | & > span:not(.sr-only) {
22 | color: $white;
23 | }
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/lib/squeeze/mailing_list/subscription.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.MailingList.Subscription do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 | import Ecto.Changeset
6 |
7 | schema "subscriptions" do
8 | field :email, :string
9 | field :type, :string
10 |
11 | timestamps()
12 | end
13 |
14 | @doc false
15 | def changeset(subscription, attrs) do
16 | subscription
17 | |> cast(attrs, [:email, :type])
18 | |> validate_format(:email, ~r/@/)
19 | |> validate_required([:email, :type])
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/lib/squeeze_web/live/dashboard/load_history_component.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.Dashboard.LoadHistoryComponent do
2 | use SqueezeWeb, :live_component
3 | @moduledoc false
4 |
5 | def show_component?(%{current_user: user}) do
6 | credential = Enum.find(user.credentials, &(&1.provider == "strava"))
7 | credential && is_nil(credential.sync_at)
8 | end
9 |
10 | @impl true
11 | def handle_event("load_history", _params, socket) do
12 | send(self(), :start_history_loader)
13 | {:noreply, socket}
14 | end
15 | end
16 |
--------------------------------------------------------------------------------
/lib/squeeze_web/views/api/follow_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.Api.FollowView do
2 | use SqueezeWeb, :view
3 | @moduledoc false
4 |
5 | alias SqueezeWeb.Api.UserView
6 |
7 | def render("followers.json", %{users: users}) do
8 | %{followers: render_many(users, UserView, "user.json", as: :user)}
9 | end
10 |
11 | def render("following.json", %{users: users}) do
12 | %{following: render_many(users, UserView, "user.json", as: :user)}
13 | end
14 |
15 | def render("follow.json", _) do
16 | %{}
17 | end
18 | end
19 |
--------------------------------------------------------------------------------
/assets/css/core/content/_main-content.scss:
--------------------------------------------------------------------------------
1 | .main-content {
2 | position: relative;
3 |
4 | // Navbar
5 | .navbar-top {
6 | padding-left: 0 !important;
7 | padding-right: 0 !important;
8 | }
9 |
10 | // Container
11 | .container-fluid {
12 | @include media-breakpoint-up(md) {
13 | padding-left: ($main-content-padding-x + $grid-gutter-width / 2) !important;
14 | padding-right: ($main-content-padding-x + $grid-gutter-width / 2) !important;
15 | }
16 | }
17 | }
18 |
--------------------------------------------------------------------------------
/assets/js/components/alert.js:
--------------------------------------------------------------------------------
1 | import { u } from 'umbrellajs';
2 |
3 | function fadeOut(alert) {
4 | alert.removeClass('show');
5 | }
6 |
7 | function removeElement(alert) {
8 | alert.remove();
9 | }
10 |
11 | function init() {
12 | const timeout = setTimeout(() => {
13 | const alert = u('.alert[data-auto-hide="true"]');
14 | fadeOut(alert);
15 | setTimeout(() => removeElement(alert), 150);
16 | }, 4000);
17 | };
18 |
19 | window.addEventListener("phx:page-loading-stop", init);
20 | window.addEventListener("load", init);
21 |
--------------------------------------------------------------------------------
/lib/squeeze/garmin/client.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Garmin.Client do
2 | @moduledoc false
3 |
4 | use Tesla
5 |
6 | alias Squeeze.Accounts.Credential
7 | alias Squeeze.Garmin.Middleware
8 |
9 | plug Tesla.Middleware.JSON
10 |
11 | def new(%Credential{token: token, token_secret: token_secret}) do
12 | new(token: token, token_secret: token_secret)
13 | end
14 |
15 | def new(opts) when is_list(opts) do
16 | Tesla.client([
17 | {Middleware.OAuth, opts}
18 | ])
19 | end
20 |
21 | def new, do: new([])
22 | end
23 |
--------------------------------------------------------------------------------
/lib/squeeze_web/templates/map/activity-map.html.eex:
--------------------------------------------------------------------------------
1 |
2 | <%= live_component(SqueezeWeb.FlashComponent, flash: @flash) %>
3 |
4 | <%= live_component(SqueezeWeb.NavbarComponent, id: "nav-bar", current_user: @current_user) %>
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 | <%= @inner_content %>
13 |
14 |
14 | <%= submit gettext("Reset Password"), class: "btn btn-primary my-4" %>
15 |
16 | <% end %>
17 |
--------------------------------------------------------------------------------
/lib/squeeze/strava/client.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Strava.Client do
2 | @moduledoc """
3 | Loads data from strava and updates the activity
4 | """
5 |
6 | alias Squeeze.Accounts
7 | alias Squeeze.Accounts.{Credential, User}
8 |
9 | def new(%User{} = user) do
10 | case Accounts.fetch_credential_by_provider(user, "strava") do
11 | {:ok, credential} -> new(credential)
12 | _ -> nil
13 | end
14 | end
15 |
16 | def new(%Credential{provider: "strava"} = credential) do
17 | Strava.Client.new(credential.access_token,
18 | refresh_token: credential.refresh_token,
19 | token_refreshed: &Accounts.update_credential(credential, Map.from_struct(&1.token))
20 | )
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/assets/css/core/grid/_grid.scss:
--------------------------------------------------------------------------------
1 | //
2 | // Grid
3 | //
4 |
5 |
6 | // Example row
7 |
8 | .row-example {
9 | > .col,
10 | > [class^="col-"] {
11 | span {
12 | display: block;
13 | padding: .75rem;
14 | color: rgb(57, 63, 73);
15 | background-color: rgb(255, 255, 255);
16 | box-shadow: rgba(0, 0, 0, 0.1) 0px 0px 0px 1px, rgba(0, 0, 0, 0.1) 0px 4px 16px;
17 | font-size: $font-size-sm;
18 | border-radius: .25rem;
19 | margin: 1rem 0;
20 | }
21 | }
22 | }
23 |
24 | .no-gutters {
25 | > .col,
26 | > [class^="col-"] {
27 | span {
28 | border-radius: 0;
29 | }
30 | }
31 | }
32 |
--------------------------------------------------------------------------------
/lib/squeeze/release.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Release do
2 | @moduledoc """
3 | Used for executing DB release tasks when run in production without Mix
4 | installed.
5 | """
6 | @app :squeeze
7 |
8 | def migrate do
9 | load_app()
10 |
11 | for repo <- repos() do
12 | {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :up, all: true))
13 | end
14 | end
15 |
16 | def rollback(repo, version) do
17 | load_app()
18 | {:ok, _, _} = Ecto.Migrator.with_repo(repo, &Ecto.Migrator.run(&1, :down, to: version))
19 | end
20 |
21 | defp repos do
22 | Application.fetch_env!(@app, :ecto_repos)
23 | end
24 |
25 | defp load_app do
26 | Application.load(@app)
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20200708041417_create_result_summaries.exs:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Repo.Migrations.CreateResultSummaries do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:race_result_summaries) do
6 | add :distance, :float
7 | add :distance_name, :string
8 | add :start_date, :date
9 | add :finisher_count, :integer
10 | add :male_winner_time, :integer
11 | add :female_winner_time, :integer
12 | add :male_avg_time, :integer
13 | add :female_avg_time, :integer
14 |
15 | add :race_id, references(:races, on_delete: :delete_all), null: false
16 |
17 | timestamps()
18 | end
19 |
20 | create index(:race_result_summaries, [:race_id])
21 | end
22 | end
23 |
--------------------------------------------------------------------------------
/lib/squeeze/challenges/score.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Challenges.Score do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 | import Ecto.Changeset
6 |
7 | alias Squeeze.Accounts.User
8 | alias Squeeze.Challenges.Challenge
9 |
10 | schema "scores" do
11 | field :amount, :float
12 |
13 | # Used for ranking only and not visible to the user
14 | field :score, :float
15 |
16 | belongs_to :user, User
17 | belongs_to :challenge, Challenge
18 |
19 | timestamps()
20 | end
21 |
22 | @doc false
23 | def changeset(score, attrs \\ %{}) do
24 | score
25 | |> cast(attrs, [:amount])
26 | |> unique_constraint(:user, name: :scores_user_id_challenge_id_index, message: "already joined")
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/lib/squeeze_web/controllers/challenge_controller.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.ChallengeController do
2 | use SqueezeWeb, :controller
3 | @moduledoc false
4 |
5 | alias Squeeze.Challenges
6 | alias Squeeze.Notifications
7 |
8 | def action(conn, _) do
9 | args = [conn, conn.params, conn.assigns.current_user]
10 | apply(__MODULE__, action_name(conn), args)
11 | end
12 |
13 | def join(conn, %{"id" => slug}, user) do
14 | challenge = Challenges.get_challenge_by_slug!(slug)
15 |
16 | with {:ok, _} <- Challenges.add_user_to_challenge(user, challenge) do
17 | Notifications.notify_user_joined(challenge, user)
18 | redirect(conn, to: Routes.challenge_path(conn, :show, challenge.slug))
19 | end
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/test/squeeze_web/views/error_view_test.exs:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.ErrorViewTest do
2 | use SqueezeWeb.ConnCase, async: true
3 |
4 | @moduletag :error_view_case
5 |
6 | # Bring render/3 and render_to_string/3 for testing custom views
7 | import Phoenix.View
8 |
9 | test "renders 404.html" do
10 | assert render_to_string(SqueezeWeb.ErrorView, "404.html", []) ==
11 | "Page not found"
12 | end
13 |
14 | test "render 500.html" do
15 | assert render_to_string(SqueezeWeb.ErrorView, "500.html", []) ==
16 | "Internal server error"
17 | end
18 |
19 | test "render any other" do
20 | assert render_to_string(SqueezeWeb.ErrorView, "505.html", []) ==
21 | "Internal server error"
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/assets/css/custom/_functions.scss:
--------------------------------------------------------------------------------
1 | //
2 | // Custom functions
3 | //
4 |
5 |
6 | // Retrieve color Sass maps
7 |
8 | @function section-color($key: "primary") {
9 | @return map-get($section-colors, $key);
10 | }
11 |
12 |
13 | // Lines colors
14 |
15 | @function shapes-primary-color($key: "step-1-gradient-bg") {
16 | @return map-get($shapes-primary-colors, $key);
17 | }
18 |
19 | @function shapes-default-color($key: "step-1-gradient-bg") {
20 | @return map-get($shapes-default-colors, $key);
21 | }
22 |
23 | @function lines-light-color($key: "step-1-gradient-bg") {
24 | @return map-get($shapes-light-colors, $key);
25 | }
26 |
27 | @function shapes-dark-color($key: "step-1-gradient-bg") {
28 | @return map-get($shapes-dark-colors, $key);
29 | }
30 |
--------------------------------------------------------------------------------
/lib/squeeze/fitbit/history_loader.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Fitbit.HistoryLoader do
2 | @moduledoc false
3 |
4 | alias Squeeze.Accounts
5 | alias Squeeze.Accounts.{Credential}
6 | alias Squeeze.Fitbit.{ActivityLoader, Client}
7 |
8 | def load_recent(%Credential{} = credential) do
9 | case fetch_activities(credential) do
10 | {:ok, response} ->
11 | response.body["activities"]
12 | |> Enum.each(&(ActivityLoader.update_or_create_activity(credential, &1)))
13 | Accounts.update_credential(credential, %{sync_at: Timex.now})
14 | _ -> {:error}
15 | end
16 | end
17 |
18 | defp fetch_activities(credential) do
19 | credential
20 | |> Client.new()
21 | |> Client.get_activities()
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/lib/squeeze_web/live/challenge_live.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.ChallengeLive do
2 | use SqueezeWeb, :live_view
3 | @moduledoc false
4 |
5 | alias Squeeze.Challenges
6 | alias Squeeze.Guardian
7 | alias Squeeze.TimeHelper
8 |
9 | @impl true
10 | def mount(_params, %{"guardian_default_token" => token}, socket) do
11 | {:ok, user, _claims} = Guardian.resource_from_token(token)
12 | date = TimeHelper.today(user) |> Timex.shift(days: -3)
13 | socket = socket
14 | |> assign(page_title: "Challenges")
15 | |> assign(current_user: user)
16 | |> assign(challenges: Challenges.list_challenges(user, ends_after: date))
17 | |> assign(podium_finishes: Challenges.podium_finishes(user))
18 |
19 | {:ok, socket}
20 | end
21 | end
22 |
--------------------------------------------------------------------------------
/lib/squeeze/challenges/challenge_activity.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Challenges.ChallengeActivity do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 | import Ecto.Changeset
6 |
7 | alias Squeeze.Challenges.Challenge
8 | alias Squeeze.Dashboard.Activity
9 |
10 | @required_fields ~w(amount)a
11 | @optional_fields ~w()a
12 |
13 | schema "challenge_activities" do
14 | field :amount, :float
15 |
16 | belongs_to :activity, Activity
17 | belongs_to :challenge, Challenge
18 |
19 | timestamps()
20 | end
21 |
22 | @doc false
23 | def changeset(challenge_activity, attrs \\ %{}) do
24 | challenge_activity
25 | |> cast(attrs, @required_fields ++ @optional_fields)
26 | |> validate_required(@required_fields)
27 | end
28 | end
29 |
--------------------------------------------------------------------------------
/assets/js/components/sign-up-form.js:
--------------------------------------------------------------------------------
1 | import 'whatwg-fetch';
2 | import { u } from 'umbrellajs';
3 |
4 | function init() {
5 | const $form = u('#sign-up-form');
6 |
7 | $form.handle('submit', (e) => {
8 | const action = $form.attr('action');
9 | const method = $form.attr('method');
10 | const options = {method: method, body: new FormData($form.first())};
11 |
12 | fetch(action, options)
13 | .then(resp => Promise.all([resp, resp.text()]))
14 | .then(([resp, body]) => {
15 | if (resp.status === 200 || resp.status === 201) {
16 | $('#auth-modal').modal('hide');
17 | } else {
18 | const html = u(body).filter('form').html();
19 | $form.html(html);
20 | }
21 | });
22 | });
23 | });
24 |
--------------------------------------------------------------------------------
/lib/squeeze/billing/invoice.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Billing.Invoice do
2 | @moduledoc false
3 |
4 | use Ecto.Schema
5 | import Ecto.Changeset
6 | alias Squeeze.Accounts.User
7 |
8 | @required_fields ~w(name amount_due due_date provider_id status)a
9 | @optional_fields ~w()
10 |
11 | schema "billing_invoices" do
12 | field :name, :string
13 | field :amount_due, :integer
14 | field :provider_id, :string
15 | field :status, :string
16 | field :due_date, :utc_datetime
17 |
18 | belongs_to :user, User
19 |
20 | timestamps()
21 | end
22 |
23 | @doc false
24 | def changeset(plan, attrs) do
25 | plan
26 | |> cast(attrs, @required_fields ++ @optional_fields)
27 | |> validate_required(@required_fields)
28 | end
29 | end
30 |
--------------------------------------------------------------------------------
/priv/repo/migrations/20190715014941_create_training_events.exs:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Repo.Migrations.CreateTrainingEvents do
2 | use Ecto.Migration
3 |
4 | def change do
5 | create table(:training_events) do
6 | add :name, :string
7 | add :distance, :float
8 | add :duration, :integer
9 |
10 | add :warmup, :boolean, default: false, null: false
11 | add :cooldown, :boolean, default: false, null: false
12 |
13 | add :plan_position, :integer, default: 0
14 | add :day_position, :integer, default: 0
15 |
16 | add :training_plan_id, references(:training_plans, on_delete: :delete_all), null: false
17 |
18 | timestamps()
19 | end
20 |
21 | create index(:training_events, [:training_plan_id])
22 | end
23 | end
24 |
--------------------------------------------------------------------------------
/assets/css/core/collapse/_accordion.scss:
--------------------------------------------------------------------------------
1 | //
2 | // Accordion
3 | //
4 |
5 |
6 | .accordion {
7 | .card-header {
8 | position: relative;
9 | cursor: pointer;
10 |
11 | &:after {
12 | content: "\ea0f";
13 | position: absolute;
14 | right: 1.5rem;
15 | top: 50%;
16 | transform: translateY(-50%);
17 | font: normal normal normal 14px/1 NucleoIcons;
18 | line-height: 0;
19 | @include transition($transition-cubic-bezier);
20 | }
21 | }
22 |
23 | .card-header[aria-expanded="false"] {
24 | &:after {
25 | content: "\ea0f";
26 | }
27 | }
28 |
29 | .card-header[aria-expanded="true"] {
30 | &:after {
31 | transform: rotate(180deg);
32 | }
33 |
34 | .heading {
35 | color: theme-color("primary");
36 | }
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/lib/squeeze_web/templates/race/_schema.html.eex:
--------------------------------------------------------------------------------
1 |
24 |
--------------------------------------------------------------------------------
/assets/css/core/icons/_icon-shape.scss:
--------------------------------------------------------------------------------
1 | //
2 | // Icon shape
3 | //
4 |
5 |
6 | .icon-shape {
7 | padding: 12px;
8 | text-align: center;
9 | display: inline-flex;
10 | align-items: center;
11 | justify-content: center;
12 | border-radius: 50%;
13 |
14 |
15 | i, svg {
16 | font-size: 1.25rem;
17 | }
18 |
19 | &.icon-lg {
20 | i, svg {
21 | font-size: 1.625rem;
22 | }
23 | }
24 |
25 | &.icon-sm {
26 | i, svg {
27 | font-size: .875rem;
28 | }
29 | }
30 |
31 | &.icon-xs {
32 | i, svg {
33 | font-size: .6rem;
34 | }
35 | }
36 |
37 | svg {
38 | width: 30px;
39 | height: 30px;
40 | }
41 |
42 | }
43 |
44 | @each $color, $value in $theme-colors {
45 | .icon-shape-#{$color} {
46 | @include icon-shape-variant(theme-color($color));
47 | }
48 | }
49 |
--------------------------------------------------------------------------------
/lib/squeeze/social/follow.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Social.Follow do
2 | @moduledoc """
3 | This module is a schema for follows
4 | """
5 |
6 | use Ecto.Schema
7 | import Ecto.Changeset
8 |
9 | alias Squeeze.Accounts.{User}
10 |
11 | @required_fields ~w()a
12 | @optional_fields ~w(pending)a
13 |
14 | schema "follows" do
15 | field :pending, :boolean
16 |
17 | belongs_to :follower, User
18 | belongs_to :followee, User
19 |
20 | timestamps()
21 | end
22 |
23 | @doc false
24 | def changeset(follow, attrs \\ %{}) do
25 | follow
26 | |> cast(attrs, @required_fields ++ @optional_fields)
27 | |> validate_required(@required_fields)
28 | |> unique_constraint(:unique_follow, name: :follows_follower_id_followee_id_index)
29 | end
30 | end
31 |
--------------------------------------------------------------------------------
/test/factories/detailed_activity_factory.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.DetailedActivityFactory do
2 | @moduledoc false
3 |
4 | alias Strava.DetailedActivity
5 |
6 | defmacro __using__(_opts) do
7 | quote do
8 | def detailed_activity_factory do
9 | timezone = "America/New_York"
10 |
11 | %DetailedActivity{
12 | id: sequence(:external_id, &(&1)),
13 | name: Enum.random(["Morning Run", "Afternoon Run", "Evening Run"]),
14 | distance: 5000.0,
15 | moving_time: 1_200, # 20 minutes
16 | start_date: Timex.now(),
17 | start_date_local: Timex.to_datetime(Timex.now(), timezone),
18 | map: %{summary_polyline: "ABCDEF"},
19 | type: "Run"
20 | }
21 | end
22 | end
23 | end
24 | end
25 |
--------------------------------------------------------------------------------
/assets/css/core/mixins/_popover.scss:
--------------------------------------------------------------------------------
1 | @mixin popover-variant($background) {
2 |
3 | background-color: $background;
4 |
5 | .popover-header {
6 | background-color: $background;
7 | color: color-yiq($background);
8 | }
9 |
10 | .popover-body {
11 | color: color-yiq($background);
12 | }
13 | .popover-header{
14 | border-color: rgba(color-yiq($background), .2);
15 | }
16 | &.bs-popover-top {
17 | .arrow::after {
18 | border-top-color: $background;
19 | }
20 | }
21 | &.bs-popover-right {
22 | .arrow::after {
23 | border-right-color: $background;
24 | }
25 | }
26 | &.bs-popover-bottom {
27 | .arrow::after {
28 | border-bottom-color: $background;
29 | }
30 | }
31 | &.bs-popover-left {
32 | .arrow::after {
33 | border-left-color: $background;
34 | }
35 | }
36 | }
--------------------------------------------------------------------------------
/lib/squeeze_web/live/dashboard/mini_calendar_component.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.Dashboard.MiniCalendarComponent do
2 | use SqueezeWeb, :live_component
3 | @moduledoc false
4 |
5 | alias Squeeze.TimeHelper
6 |
7 | def data(%{activity_map: activity_map} = assigns) do
8 | dates(assigns)
9 | |> Enum.map(fn(date) ->
10 | %{
11 | date: date,
12 | activities: Map.get(activity_map, date, [])
13 | }
14 | end)
15 | end
16 |
17 | def dates(assigns) do
18 | today = today(assigns)
19 | end_date = Timex.end_of_week(today)
20 | start_date = today |> Timex.shift(weeks: -4) |> Timex.beginning_of_week()
21 | Date.range(start_date, end_date)
22 | end
23 |
24 | def today(%{current_user: user}) do
25 | TimeHelper.today(user)
26 | end
27 | end
28 |
--------------------------------------------------------------------------------
/lib/squeeze/garmin/middleware/oauth.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Garmin.Middleware.OAuth do
2 | @moduledoc false
3 |
4 | @behaviour Tesla.Middleware
5 |
6 | @config Application.compile_env(:squeeze, Squeeze.Garmin)
7 |
8 | alias Squeeze.OAuth1
9 |
10 | def call(env, next, opts) do
11 | creds = oauth_credentials(opts)
12 | method = env.method |> Atom.to_string() |> String.upcase()
13 | params = OAuth1.sign(method, env.url, env.query, creds)
14 | {header, _req_params} = OAuth1.header(params)
15 | env
16 | |> Tesla.put_headers([header])
17 | |> Tesla.run(next)
18 | end
19 |
20 | defp oauth_credentials(opts) do
21 | @config
22 | |> Keyword.take([:consumer_key, :consumer_secret])
23 | |> Keyword.merge(opts)
24 | |> OAuth1.credentials()
25 | end
26 | end
27 |
--------------------------------------------------------------------------------
/lib/squeeze_web/templates/modal/past-due.html.eex:
--------------------------------------------------------------------------------
1 |
15 | <%= submit gettext("Reset Password"), class: "btn btn-spinner btn-primary my-4" %>
16 |
17 | <% end %>
18 |
--------------------------------------------------------------------------------
/lib/squeeze_web/live/race_live/upcoming_races_card.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.RaceLive.UpcomingRacesCard do
2 | use SqueezeWeb, :live_component
3 | @moduledoc false
4 |
5 | alias Squeeze.Distances
6 |
7 | @colors ~w(
8 | blue
9 | indigo
10 | purple
11 | red
12 | orange
13 | green
14 | teal
15 | cyan
16 | )
17 |
18 | def race_date(%{start_date: date}) do
19 | date
20 | |> Timex.format!("%B #{Ordinal.ordinalize(date.day)}, %Y", :strftime)
21 | end
22 |
23 | def bg_color(model) do
24 | idx = rem(model.id, length(@colors))
25 | color = Enum.at(@colors, idx)
26 | "bg-gradient-#{color}"
27 | end
28 |
29 | def distance_name(distance, current_user) do
30 | Distances.distance_name(distance, imperial: current_user.user_prefs.imperial)
31 | end
32 | end
33 |
--------------------------------------------------------------------------------
/lib/squeeze_web/gettext.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.Gettext do
2 | @moduledoc """
3 | A module providing Internationalization with a gettext-based API.
4 |
5 | By using [Gettext](https://hexdocs.pm/gettext),
6 | your module gains a set of macros for translations, for example:
7 |
8 | import SqueezeWeb.Gettext
9 |
10 | # Simple translation
11 | gettext "Here is the string to translate"
12 |
13 | # Plural translation
14 | ngettext "Here is the string to translate",
15 | "Here are the strings to translate",
16 | 3
17 |
18 | # Domain-based translation
19 | dgettext "errors", "Here is the error message to translate"
20 |
21 | See the [Gettext Docs](https://hexdocs.pm/gettext) for detailed usage.
22 | """
23 | use Gettext, otp_app: :squeeze
24 | end
25 |
--------------------------------------------------------------------------------
/test/factories/payment_method_factory.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.PaymentMethodFactory do
2 | @moduledoc false
3 |
4 | alias Faker.{Address, Lorem, Person}
5 | alias Squeeze.Billing.PaymentMethod
6 |
7 | defmacro __using__(_opts) do
8 | quote do
9 | def payment_method_factory do
10 | company = Enum.random(["Visa", "Mastercard", "American Express"])
11 | owner = Person.name()
12 |
13 | %PaymentMethod{
14 | owner_name: owner,
15 | address_zip: Address.zip(),
16 |
17 | exp_month: Enum.random(1..12),
18 | exp_year: Timex.today.year + Enum.random(1..6),
19 | last4: "#{Enum.random(1000..9999)}",
20 | stripe_id: "card_#{Lorem.characters(15)}",
21 | user: build(:user)
22 | }
23 | end
24 | end
25 | end
26 | end
27 |
--------------------------------------------------------------------------------
/lib/squeeze/email.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Email do
2 | use Bamboo.Phoenix, view: SqueezeWeb.EmailView
3 |
4 | @moduledoc false
5 |
6 | alias Squeeze.CompanyHelper
7 |
8 | def welcome_email(user) do
9 | base_email()
10 | |> to(user.email)
11 | |> subject("Welcome to OpenPace!")
12 | |> assign(:user, user)
13 | |> render(:welcome)
14 | end
15 |
16 | def reset_password_email(user, link) do
17 | base_email()
18 | |> to(user.email)
19 | |> subject("Your Reset Password Link")
20 | |> assign(:user, user)
21 | |> assign(:link, link)
22 | |> render(:reset_password)
23 | end
24 |
25 | defp base_email do
26 | new_email()
27 | |> from(CompanyHelper.team_email())
28 | |> bcc(CompanyHelper.team_email())
29 | |> put_layout({SqueezeWeb.LayoutView, :email})
30 | end
31 | end
32 |
--------------------------------------------------------------------------------
/lib/squeeze_web/views/api/challenge_activity_view.ex:
--------------------------------------------------------------------------------
1 | defmodule SqueezeWeb.Api.ChallengeActivityView do
2 | use SqueezeWeb, :view
3 | @moduledoc false
4 |
5 | def render("index.json", %{challenge_activities: challenge_activities}) do
6 | %{challenge_activities: render_many(challenge_activities, SqueezeWeb.Api.ChallengeActivityView, "challenge_activity.json")}
7 | end
8 |
9 | def render("challenge_activity.json", %{challenge_activity: challenge_activity}) do
10 | activity = challenge_activity.activity
11 |
12 | %{
13 | id: challenge_activity.id,
14 | amount: challenge_activity.amount,
15 | activity: render_one(activity, SqueezeWeb.Api.ActivityView, "activity.json", as: :activity),
16 | user: render_one(activity.user, SqueezeWeb.Api.UserView, "user.json", as: :user)
17 | }
18 | end
19 | end
20 |
--------------------------------------------------------------------------------
/assets/css/core/vendors/_datatables.scss:
--------------------------------------------------------------------------------
1 | //
2 | // Datatables
3 | //
4 |
5 | .dataTables_wrapper {
6 | font-size: $font-size-sm;
7 | }
8 |
9 | table.dataTable {
10 | margin-bottom: $card-spacer-y !important;
11 | border-bottom: 1px solid $table-border-color;
12 |
13 | tbody {
14 | > tr.selected {
15 | background-color: theme-color("primary");
16 | }
17 | }
18 | }
19 |
20 | .dataTables_length,
21 | .dataTables_info,
22 | .dt-buttons {
23 | padding-left: $card-spacer-x;
24 | }
25 |
26 | .dataTables_length {
27 | .form-control {
28 | margin: 0 .375rem;
29 | }
30 | }
31 |
32 | .dataTables_filter {
33 | padding-right: $card-spacer-x;
34 | display: inline-block;
35 | float: right;
36 | }
37 |
38 | .dataTables_paginate {
39 | padding-right: $card-spacer-x;
40 | }
41 |
--------------------------------------------------------------------------------
/lib/squeeze/stringable.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Stringable do
2 | @moduledoc """
3 | This ecto type allows for both integers and strings. This is used when we want
4 | to store segment_id (an external identifier) as a string and not an integer.
5 | """
6 | @behaviour Ecto.Type
7 |
8 | def cast(s) when is_binary(s), do: {:ok, s}
9 |
10 | def cast(val) do
11 | if String.Chars.impl_for(val) do
12 | {:ok, to_string(val)}
13 | else
14 | {:error, "cannot convert to string"}
15 | end
16 | end
17 |
18 | def dump(str) do
19 | Ecto.Type.dump(:string, str)
20 | end
21 |
22 | def load(str) do
23 | Ecto.Type.load(:string, str)
24 | end
25 |
26 | def type do
27 | Ecto.Type.type(:string)
28 | end
29 |
30 | def embed_as(_), do: :self
31 |
32 | def equal?(left, right), do: left == right
33 | end
34 |
--------------------------------------------------------------------------------
/lib/squeeze/utils.ex:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Utils do
2 | @moduledoc """
3 | Utility functions
4 | """
5 |
6 | def key_to_atom(map) do
7 | Enum.reduce(map, %{}, fn
8 | # String.to_existing_atom saves us from overloading the VM by
9 | # creating too many atoms. It'll always succeed because all the fields
10 | # in the database already exist as atoms at runtime.
11 | {key, value}, acc when is_atom(key) -> Map.put(acc, key, value)
12 | {key, value}, acc when is_binary(key) -> Map.put(acc, String.to_existing_atom(key), value)
13 | end)
14 | end
15 |
16 | def random_float(a, b), do: a + (b - a) * :rand.uniform()
17 |
18 | def random_int(a, b), do: a + :rand.uniform(b - a)
19 |
20 | def cast_float(nil), do: nil
21 | def cast_float(x) when is_integer(x), do: x * 1.0
22 | def cast_float(x), do: x
23 | end
24 |
--------------------------------------------------------------------------------
/test/squeeze/challenges/score_updater_test.exs:
--------------------------------------------------------------------------------
1 | defmodule Squeeze.Challenges.ScoreUpdaterTest do
2 | use Squeeze.DataCase
3 |
4 | # import Squeeze.Factory
5 |
6 | # alias Ecto.Changeset
7 | # alias Squeeze.Challenges
8 | # alias Squeeze.Challenges.{Challenge, Score}
9 |
10 | # describe "#total_amount/2" do
11 | # test "with segment challenge" do
12 | # end
13 |
14 | # test "with multiple activities" do
15 | # end
16 | # end
17 |
18 | # describe "#amount/2" do
19 | # test "with a distance challenge" do
20 | # insert(:challenge, challenge_type: :distance) |> with_scores(1)
21 | # end
22 |
23 | # test "with a time challenge" do
24 | # end
25 |
26 | # test "with an altitude challenge" do
27 | # end
28 |
29 | # test "with a segment challenge" do
30 | # end
31 | # end
32 | end
33 |
--------------------------------------------------------------------------------
/lib/squeeze_web/templates/shared/flash.html.eex:
--------------------------------------------------------------------------------
1 | <% info_msg = get_flash(@conn, :info) %>
2 | <% error_msg = get_flash(@conn, :error) %>
3 |
4 | <%= if info_msg do %>
5 |