summaryrefslogtreecommitdiff
path: root/lib/powerdnsex/models/resource_record_set.ex
blob: d02d2c9594e2c0665f04d048501d279484f2fedd (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
defmodule PowerDNSex.Models.ResourceRecordSet do

  alias PowerDNSex.Models.Record

  defstruct [:name, :type, :ttl, :records, :changetype]
  @permited_attrs [:ttl, :records]

  def build(%{records: records} = rrset_attrs) when is_list(records) do
    build_rrset(rrset_attrs)
  end

  def as_body(%__MODULE__{} = rrset) do
    %{ rrsets: [
       %{
         name: rrset.name,
         type: rrset.type,
         ttl: rrset.ttl,
         changetype: rrset.changetype,
         records: Record.as_body(rrset.records)
       }
    ]}
    |> Poison.encode!
  end

  def find(rrsets, %{} = attrs) when is_list(rrsets) do
    Enum.find(rrsets, fn(rrset)->
      Enum.all?(attrs, fn({attr, attr_value})->
        if Enum.member?(Map.keys(%__MODULE__{}), attr) do
          equal_attr?(attr, attr_value, rrset)
        else
          Record.find(rrset.records, %{attr => attr_value})
        end
      end)
    end)
  end

  def update(%__MODULE__{} = rrset, %{} = new_attrs) do
    format_attrs(new_attrs, rrset)
    |> Enum.reduce(rrset, fn( {attr, value}, rrset) ->
      %{rrset | attr => value}
    end)
  end

  ###
  # Private
  ###
  #
  defp format_attrs(new_attrs, rrset) do
    record = %Record{content: new_attrs.content, disabled: new_attrs.disabled }
     %{
       records: [record],
       ttl: Map.get(new_attrs, :ttl, rrset.ttl)
     }
  end

  defp set_attrs(rrset, attr_name, attrs) do
    if Map.has_key?(attrs, attr_name) do
      attr_value = case attr_name do
                        :records -> Record.build(Map.fetch!(attrs, attr_name))
                        _         -> Map.fetch!(attrs, attr_name)
                   end

      %{ rrset | attr_name => attr_value }
    else
      rrset
    end
  end

  defp equal_attr?(attr, attr_value, rrset) do
    attr_atom = if is_binary(attr), do: String.to_atom(attr), else: attr
    Map.get(rrset, attr_atom) == attr_value
  end

  defp build_rrset(rrset_attrs) do
    %__MODULE__{}
    |> Map.keys
    |> Enum.reduce(%__MODULE__{}, &(set_attrs(&2, &1, rrset_attrs)))
  end
end