Packages
integratedb
0.1.0
IntegrateDB is a database sharing system. It provides integration primitives and data ownership and migration controls. Use it to integrate applications directly through a Postgres database.
Current section
Files
Jump to
Current section
Files
lib/integrate/claims.ex
defmodule Integrate.Claims do
@moduledoc """
The Claims context.
"""
import Ecto.Query, warn: false
alias Integrate.Repo
alias Integrate.Specification.Spec
alias Integrate.Claims.Claim
@doc """
Returns the list of claims.
## Examples
iex> list_claims()
[%Claim{}, ...]
"""
def list_claims do
Repo.all(Claim)
end
@doc """
Gets a single claim.
Raises `Ecto.NoResultsError` if the Claim does not exist.
## Examples
iex> get_claim!(123)
%Claim{}
iex> get_claim!(456)
** (Ecto.NoResultsError)
"""
def get_claim!(id), do: Repo.get!(Claim, id)
@doc """
Gets the associated claims for a spec, preloaded with their
child associations.
## Examples
iex> get_by_spec(%Spec{})
[%Claim{}, ...]
"""
def get_by_spec(%Spec{} = spec) do
associations = [
claims: [
alternatives: [
columns: [
:alternatives
]
]
]
]
spec = Repo.preload(spec, associations)
spec.claims
end
@doc """
Creates a claim.
## Examples
iex> create_claim(%Spec{} = spec, %{field: value})
{:ok, %Claim{}}
iex> create_claim(%Spec{} = spec, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def create_claim(%Spec{id: spec_id}, attrs \\ %{}) do
attrs =
attrs
|> Map.put(:spec_id, spec_id)
%Claim{}
|> Claim.changeset(attrs)
|> Repo.insert()
end
@doc """
Initialises a `claim` with its `alternatives`.
Returns a changeset.
## Examples
iex> init_claim_with_alternatives([%ClaimAlternative{}])
%Ecto.Changeset{}
"""
def init_claim_with_alternatives(alternatives, attrs \\ %{}) do
%Claim{}
|> Claim.changeset_with_alternatives(alternatives, attrs)
end
@doc """
Updates a claim.
## Examples
iex> update_claim(claim, %{field: new_value})
{:ok, %Claim{}}
iex> update_claim(claim, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def update_claim(%Claim{} = claim, attrs) do
claim
|> Claim.changeset(attrs)
|> Repo.update()
end
@doc """
Deletes a claim.
## Examples
iex> delete_claim(claim)
{:ok, %Claim{}}
iex> delete_claim(claim)
{:error, %Ecto.Changeset{}}
"""
def delete_claim(%Claim{} = claim) do
Repo.delete(claim)
end
@doc """
Returns an `%Ecto.Changeset{}` for tracking claim changes.
## Examples
iex> change_claim(claim)
%Ecto.Changeset{data: %Claim{}}
"""
def change_claim(%Claim{} = claim, attrs \\ %{}) do
Claim.changeset(claim, attrs)
end
alias Integrate.Claims.ClaimAlternative
@doc """
Returns the list of claim alternatives.
## Examples
iex> list_claim_alternatives()
[%ClaimAlternative{}, ...]
"""
def list_claim_alternatives do
Repo.all(ClaimAlternative)
end
@doc """
Gets a single claim alternative.
Raises `Ecto.NoResultsError` if the ClaimAlternative does not exist.
## Examples
iex> get_claim_alternative!(123)
%ClaimAlternative{}
iex> get_claim_alternative!(456)
** (Ecto.NoResultsError)
"""
def get_claim_alternative!(id), do: Repo.get!(ClaimAlternative, id)
@doc """
Creates a claim alternative.
## Examples
iex> create_claim_alternative(%Claim{}, %{field: value})
{:ok, %ClaimAlternative{}}
iex> create_claim_alternative(%Claim{}, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def create_claim_alternative(%Claim{id: claim_id}, attrs \\ %{}) do
attrs =
attrs
|> Map.put(:claim_id, claim_id)
%ClaimAlternative{}
|> ClaimAlternative.changeset(attrs)
|> Repo.insert()
end
@doc """
Initialises a `claim_alternative` and its child `columns` at the same time.
Returns a changeset.
## Examples
iex> init_claim_alternative_with_columns([%Column{}], %{field: value})
%Ecto.Changeset{}
iex> init_claim_alternative_with_columns(%Claim{}, [%Column{}], %{field: value})
%Ecto.Changeset{}
"""
def init_claim_alternative_with_columns(columns, attrs) do
%ClaimAlternative{}
|> ClaimAlternative.changeset_with_columns(columns, attrs)
end
def init_claim_alternative_with_columns(%Claim{id: claim_id}, columns, attrs) do
attrs =
attrs
|> Map.put(:claim_id, claim_id)
%ClaimAlternative{}
|> ClaimAlternative.changeset_with_columns(columns, attrs)
end
@doc """
Updates a claim alternative.
## Examples
iex> update_claim_alternative(claim, %{field: new_value})
{:ok, %ClaimAlternative{}}
iex> update_claim_alternative(claim, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def update_claim_alternative(%ClaimAlternative{} = claim_alternative, attrs) do
claim_alternative
|> ClaimAlternative.changeset(attrs)
|> Repo.update()
end
@doc """
Deletes a claim alternative.
## Examples
iex> delete_claim_alternative(claim)
{:ok, %ClaimAlternative{}}
iex> delete_claim_alternative(claim)
{:error, %Ecto.Changeset{}}
"""
def delete_claim_alternative(%ClaimAlternative{} = claim_alternative) do
Repo.delete(claim_alternative)
end
@doc """
Returns an `%Ecto.Changeset{}` for tracking claim changes.
## Examples
iex> change_claim(claim)
%Ecto.Changeset{data: %ClaimAlternative{}}
"""
def change_claim_alternative(%ClaimAlternative{} = claim_alternative, attrs \\ %{}) do
ClaimAlternative.changeset(claim_alternative, attrs)
end
alias Integrate.Claims.Column
@doc """
Returns the list of columns.
## Examples
iex> list_columns()
[%Column{}, ...]
"""
def list_columns do
Repo.all(Column)
end
@doc """
Gets a single column.
Raises `Ecto.NoResultsError` if the Column does not exist.
## Examples
iex> get_column!(123)
%Column{}
iex> get_column!(456)
** (Ecto.NoResultsError)
"""
def get_column!(id), do: Repo.get!(Column, id)
@doc """
Creates a column.
## Examples
iex> create_column(%Claim{} = claim, %{field: value})
{:ok, %Column{}}
iex> create_column(%Claim{} = claim, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def create_column(%ClaimAlternative{id: claim_alternative_id}, attrs \\ %{}) do
attrs =
attrs
|> Map.put(:claim_alternative_id, claim_alternative_id)
%Column{}
|> Column.changeset(attrs)
|> Repo.insert()
end
@doc """
Initialise a column.
## Examples
iex> init_column_with_alternatives([%ColumnAlternative{}])
%Ecto.Changeset{}
"""
def init_column_with_alternatives(alternatives, attrs \\ %{}) do
%Column{}
|> Column.changeset_with_alternatives(alternatives, attrs)
end
@doc """
Updates a column.
## Examples
iex> update_column(column, %{field: new_value})
{:ok, %Column{}}
iex> update_column(column, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def update_column(%Column{} = column, attrs) do
column
|> Column.changeset(attrs)
|> Repo.update()
end
@doc """
Deletes a column.
## Examples
iex> delete_column(column)
{:ok, %Column{}}
iex> delete_column(column)
{:error, %Ecto.Changeset{}}
"""
def delete_column(%Column{} = column) do
Repo.delete(column)
end
@doc """
Returns an `%Ecto.Changeset{}` for tracking column changes.
## Examples
iex> change_column(column)
%Ecto.Changeset{data: %Column{}}
"""
def change_column(%Column{} = column, attrs \\ %{}) do
Column.changeset(column, attrs)
end
alias Integrate.Claims.ColumnAlternative
@doc """
Returns the list of column_alternatives.
## Examples
iex> list_column_alternatives()
[%ColumnAlternative{}, ...]
"""
def list_column_alternatives do
Repo.all(ColumnAlternative)
end
@doc """
Gets a single column_alternative.
Raises `Ecto.NoResultsError` if the ColumnAlternative does not exist.
## Examples
iex> get_column_alternative!(123)
%ColumnAlternative{}
iex> get_column_alternative!(456)
** (Ecto.NoResultsError)
"""
def get_column_alternative!(id), do: Repo.get!(ColumnAlternative, id)
@doc """
Creates a column_alternative.
## Examples
iex> create_column_alternative(%Column{} = column, %{field: value})
{:ok, %ColumnAlternative{}}
iex> create_column_alternative(%Column{} = column, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def create_column_alternative(%Column{id: column_id}, attrs \\ %{}) do
attrs =
attrs
|> Map.put(:column_id, column_id)
%ColumnAlternative{}
|> ColumnAlternative.changeset(attrs)
|> Repo.insert()
end
@doc """
Initialise a column_alternative.
## Examples
iex> init_column_alternative(%{field: value})
%Ecto.Changeset{}
"""
def init_column_alternative(attrs) do
%ColumnAlternative{}
|> ColumnAlternative.changeset(attrs)
end
@doc """
Updates a column_alternative.
## Examples
iex> update_column_alternative(column_alternative, %{field: new_value})
{:ok, %ColumnAlternative{}}
iex> update_column_alternative(column_alternative, %{field: bad_value})
{:error, %Ecto.Changeset{}}
"""
def update_column_alternative(%ColumnAlternative{} = column_alternative, attrs) do
column_alternative
|> ColumnAlternative.changeset(attrs)
|> Repo.update()
end
@doc """
Deletes a column_alternative.
## Examples
iex> delete_column_alternative(column_alternative)
{:ok, %ColumnAlternative{}}
iex> delete_column_alternative(column_alternative)
{:error, %Ecto.Changeset{}}
"""
def delete_column_alternative(%ColumnAlternative{} = column_alternative) do
Repo.delete(column_alternative)
end
@doc """
Returns an `%Ecto.Changeset{}` for tracking column_alternative changes.
## Examples
iex> change_column_alternative(column_alternative)
%Ecto.Changeset{data: %ColumnAlternative{}}
"""
def change_column_alternative(%ColumnAlternative{} = column_alternative, attrs \\ %{}) do
ColumnAlternative.changeset(column_alternative, attrs)
end
@doc """
Coerce a list of claims to a `{schema, table}: column_names` map.
## Examples
iex> to_columns_map([%Claim{}])
%{{schema, table}: [column_name, ...], ...}
"""
def to_columns_map(claims) do
claims
|> Enum.reduce(%{}, fn %Claim{} = claim, acc ->
claim.alternatives
|> Enum.reduce(acc, fn %ClaimAlternative{} = claim_alt, acc ->
key = {claim_alt.schema, claim_alt.table}
val = Map.get(acc, key, %{})
val =
claim_alt.columns
|> Enum.reduce(val, fn %Column{} = col, acc ->
col.alternatives
|> Enum.reduce(acc, fn %ColumnAlternative{} = col_alt, acc ->
Map.put(acc, col_alt.name, true)
end)
end)
Map.put(acc, key, val)
end)
end)
end
def column_grants_for(name, privilege \\ "SELECT") do
query =
from g in "role_column_grants",
prefix: "information_schema",
select: {
g.table_schema,
g.table_name,
g.column_name
},
where:
g.grantee == ^name and
g.privilege_type == ^privilege
query
|> Repo.all()
end
def to_grants_map(results) do
results
|> Enum.reduce(%{}, fn {schema_name, table_name, column_name}, acc ->
key = {schema_name, table_name}
val =
acc
|> Map.get(key, %{})
|> Map.put(column_name, true)
acc
|> Map.put(key, val)
end)
end
end