ajout de wot/certifiers_of

lib/bma/wot/certifiersof.ex

 defmodule BMA.Wot.CertifiersOf do
-  def get(search) do
-    Poison.encode!("#TODO " <> search)
+
+  defp get_id_entry(pub, entries_id) do
+    Enum.reduce(entries_id, nil, fn entry, acc ->
+      case Map.get(entry, :pub) == pub do
+        true -> entry
+        false -> acc
+      end
+    end)
+  end
+
+  def get(
+        search,
+        db_id \\ 'data/global_iindex',
+        db_cert \\ 'data/global_cindex',
+        db_block \\ 'data/global_bindex'
+      ) do
+    {_, :iindex} = :dets.open_file(:iindex, [{:file, db_id}, {:type, :set}])
+    entries_id = :dets.match(:iindex, {:_, :"$2"}) |> Enum.map(fn x -> List.first(x) end)
+
+    {_, :cindex} = :dets.open_file(:cindex, [{:file, db_cert}, {:type, :set}])
+    entries_cert = :dets.match(:cindex, {:_, :"$2"}) |> Enum.map(fn x -> List.first(x) end)
+
+    {_, :bindex} = :dets.open_file(:bindex, [{:file, db_block}, {:type, :set}])
+    entries_block = :dets.match(:bindex, {:_, :"$2"}) |> Enum.map(fn x -> List.first(x) end)
+
+    # entry de iindex correspondant à search
+    entry_id =
+      Enum.reduce(entries_id, nil, fn entry, acc ->
+        case Map.get(entry, :pub) == search or Map.get(entry, :id) == search do
+          true -> entry
+          false -> acc
+        end
+      end)
+
+    # liste des certifications dont search est le receiver
+    certs =
+      Enum.filter(entries_cert, fn cert -> Map.get(cert, :receiver) == Map.get(entry_id, :pub) end)
+
+    # creation de la liste du champ "certifications" de la requete
+    list_certs =
+      Enum.reduce(certs, [], fn cert, acc ->
+        # entry de iindex correspondant au issuer de la certification
+        entry_id_ = get_id_entry(Map.get(cert, :pub), entries_id)
+        [number, hash] = String.split(Map.get(cert, :written_on), "-")
+
+        # numéro de block sur lequel est crée la certification
+        block_cert_time =
+          String.split(Map.get(cert, :created_on), "-") |> List.first() |> String.to_integer()
+
+        # medianTime block sur lequel est crée la certification
+        medianTime =
+          Enum.reduce(entries_block, nil, fn block, acc ->
+            case Map.get(block, :number) == block_cert_time do
+              true -> Map.get(block, :medianTime)
+              _ -> acc
+            end
+          end)
+
+        [
+          %{
+            pubKey: Map.get(cert, :pub),
+            uid: Map.get(entry_id_, :uid),
+            isMember: Map.get(entry_id_, :isMember),
+            wasMember: Map.get(entry_id_, :wasMember),
+            sigDate: Map.get(entry_id_, :written_on),
+            written: %{number: String.to_integer(number), hash: hash},
+            cert_time: %{block: block_cert_time, medianTime: medianTime},
+            signature: Map.get(cert, :sig)
+          }
+          | acc
+        ]
+      end)
+
+    map_to_return = %{
+      pubKey: Map.get(entry_id, :pub),
+      uid: Map.get(entry_id, :uid),
+      sigDate: Map.get(entry_id, :written_on),
+      isMember: Map.get(entry_id, :isMember),
+      certifications: list_certs
+    }
+
+    Poison.encode(map_to_return)
   end
 end

test/http/wot/members_test.exs

@@ -91,8 +91,6 @@ defmodule BMA.Wot.MembersTest do
 
     :file.delete("test/global_iindex")
     {:ok, json: BMA.Wot.Members.get('test/global_iindex')}
-
-
   end
 
   test "members query", state do