Implement platform plan apis (#793)

Author: michaeljguarino

apps/core/lib/core/policies/payments.ex

@@ -1,8 +1,15 @@
 defmodule Core.Policies.Payments do
   use Piazza.Policy
-  alias Core.Schema.{Plan, Subscription, User}
+  import Core.Policies.Utils
+  alias Core.Schema.{Plan, Subscription, PlatformPlan, PlatformSubscription, User}
   alias Core.Policies.Publisher
 
+  def can?(user, %PlatformPlan{}, _),
+    do: check_rbac(user, :billing, account: user.account)
+
+  def can?(user, %PlatformSubscription{}, _),
+    do: check_rbac(user, :billing, account: user.account)
+
   def can?(user, %Plan{} = plan, action) do
     %{repository: %{publisher: pub}} = Core.Repo.preload(plan, [repository: :publisher])
     Publisher.can?(user, pub, action)
@@ -27,4 +34,4 @@ defmodule Core.Policies.Payments do
     do: can?(user, apply_changes(cs), action)
 
   def can?(_, _, _), do: {:error, :forbidden}
-end
+end

apps/core/lib/core/schema/account.ex

@@ -1,7 +1,7 @@
 defmodule Core.Schema.Account do
   use Piazza.Ecto.Schema
   use Arc.Ecto.Schema
-  alias Core.Schema.{User, DomainMapping}
+  alias Core.Schema.{User, DomainMapping, PlatformSubscription}
 
   schema "accounts" do
     field :name,                 :string
@@ -12,6 +12,7 @@ defmodule Core.Schema.Account do
 
     belongs_to :root_user, User
     has_many :domain_mappings, DomainMapping, on_replace: :delete
+    has_one :subscription, PlatformSubscription
 
     timestamps()
   end

apps/core/lib/core/schema/platform_plan.ex

@@ -0,0 +1,65 @@
+defmodule Core.Schema.PlatformPlan do
+  use Piazza.Ecto.Schema
+
+  defenum Period, monthly: 0, yearly: 1
+  defenum Dimension, user: 0
+
+  defmodule LineItem do
+    use Piazza.Ecto.Schema
+    alias Core.Schema.PlatformPlan.{Period, Dimension}
+
+    embedded_schema do
+      field :name,        :string
+      field :dimension,   Dimension
+      field :external_id, :string
+      field :cost,        :integer
+      field :period,      Period
+    end
+
+    @valid ~w(name cost period dimension external_id)a
+
+    def changeset(model, attrs \\ %{}) do
+      model
+      |> cast(attrs, @valid)
+      |> validate_required([:name, :cost, :period, :dimension])
+    end
+  end
+
+  schema "platform_plans" do
+    field :name,        :string
+    field :visible,     :boolean, default: true
+    field :cost,        :integer
+    field :period,      Period
+    field :external_id, :string
+
+    embeds_one :features, Features, on_replace: :update do
+      boolean_fields [:vpn]
+    end
+
+    embeds_many :line_items, LineItem, on_replace: :delete
+
+    timestamps()
+  end
+
+  def visible(query \\ __MODULE__), do: from(p in query, where: p.visible)
+
+  def ordered(query \\ __MODULE__, order \\ [asc: :name]),
+    do: from(p in query, order_by: ^order)
+
+  def features(), do: __MODULE__.Features.__schema__(:fields) -- [:id]
+
+  @valid ~w(name visible cost period external_id)a
+
+  def changeset(schema, attrs \\ %{}) do
+    schema
+    |> cast(attrs, @valid)
+    |> cast_embed(:line_items)
+    |> cast_embed(:features, with: &features_changeset/2)
+    |> validate_required([:name, :visible])
+  end
+
+  def features_changeset(model, attrs) do
+    model
+    |> cast(attrs, features())
+  end
+end

apps/core/lib/core/schema/platform_subscription.ex

@@ -0,0 +1,65 @@
+defmodule Core.Schema.PlatformSubscription do
+  use Piazza.Ecto.Schema
+  alias Core.Schema.{Account, PlatformPlan}
+
+  defmodule LineItem do
+    use Piazza.Ecto.Schema
+    alias Core.Schema.PlatformPlan
+
+    embedded_schema do
+      field :dimension,   PlatformPlan.Dimension
+      field :quantity,    :integer
+      field :external_id, :string
+    end
+
+    @valid ~w(dimension quantity external_id)a
+
+    def changeset(model, attrs \\ %{}) do
+      model
+      |> cast(attrs, @valid)
+      |> validate_required([:dimension, :quantity])
+    end
+  end
+
+  schema "platform_subscriptions" do
+    field :external_id, :string
+
+    embeds_many :line_items, LineItem, on_replace: :delete
+    belongs_to  :account,    Account
+    belongs_to  :plan,       PlatformPlan
+
+    timestamps()
+  end
+
+  @valid ~w(account_id plan_id)a
+
+  def dimension(%__MODULE__{line_items: items}, dim) do
+    case Enum.find(items, & &1.dimension == dim) do
+      %{quantity: quantity} -> quantity
+      _ -> 0
+    end
+  end
+
+  def line_item(%__MODULE__{line_items: items}, dim),
+    do: Enum.find(items, & &1.dimension == dim)
+
+  def changeset(schema, attrs \\ %{}) do
+    schema
+    |> cast(attrs, @valid)
+    |> cast_embed(:line_items)
+    |> validate_required([:account_id, :plan_id])
+    |> foreign_key_constraint(:account_id)
+    |> foreign_key_constraint(:plan_id)
+    |> unique_constraint(:account_id)
+  end
+
+  @stripe_valid ~w(external_id)a
+
+  def stripe_changeset(schema, attrs \\ %{}) do
+    schema
+    |> cast(attrs, @stripe_valid)
+    |> cast_embed(:line_items)
+    |> unique_constraint(:account_id)
+    |> unique_constraint(:external_id)
+  end
+end