chore: add multiple validation handling

chore: seed error log messages

lib/arke/link_manager.ex

@@ -40,14 +40,15 @@ defmodule Arke.LinkManager do
 
   def add_node(project, parent, child, type, metadata)
       when is_binary(parent) and is_binary(child) do
-    unit_parent = QueryManager.get_by(id: parent, project: project)
-    unit_child = QueryManager.get_by(id: child, project: project)
-
-    add_node(project, unit_parent, unit_child, type, metadata)
+    with %Unit{}=unit_parent <- QueryManager.get_by(id: parent, project: project),
+         %Unit{}=unit_child <- QueryManager.get_by(id: child, project: project) do
+      add_node(project, unit_parent, unit_child, type, metadata)
+      else
+      _ ->  Error.create(:link, "parent: `#{parent}` or child: `#{child}` not found")
+    end
   end
 
-  def add_node(_project, _parent, _child, _type, _metadata),
-    do: Error.create(:link, "invalid parameters")
+  def add_node(_project,  _parent, _child, _type, _metadata), do: Error.create(:link, "invalid parameters")
 
   def update_node(project, %Unit{} = parent, %Unit{} = child, type, metadata) do
     arke_link = ArkeManager.get(:arke_link, :arke_system)

lib/arke/validator.ex

@@ -243,16 +243,17 @@ defmodule Arke.Validator do
   defp check_by_type(errors, %{arke_id: :string} = parameter, value)
        when is_binary(value) or is_atom(value) or is_list(value) do
     errors
-    #todo: if multiple is true validate the values that must be the same type
     # also update the insert in arke postgres
     |> check_max_length(parameter, value)
     |> check_min_length(parameter, value)
     |> check_values(parameter, value)
+    |> check_multiple(parameter, value)
   end
 
   defp check_by_type(errors, %{arke_id: :string} = parameter, _value),
     do: errors ++ [{parameter.data.label, "must be a string"}]
 
+  # --- start Enum ---
   defp check_values(errors, %{data: %{values: nil}} = _parameter, _value), do: errors
 
   defp check_values(
@@ -287,6 +288,7 @@ defmodule Arke.Validator do
          value
        ),
        do: errors ++ [{value, "#{label} must be a list of #{type}}"}]
+ defp check_values(errors,_parameter,_value), do: errors
 
   defp check_values_type(value, type) do
     condition =
@@ -298,6 +300,19 @@ defmodule Arke.Validator do
 
     Enum.all?(value, &condition.(&1))
   end
+  # --- end Enum ---
+  # --- start Multiple ---
+  defp check_multiple(errors, %{id: id, data: %{multiple: false}} = _parameter, value) when is_list(value), do: errors ++ [{"multiple values are not allowed for", id}]
+  defp check_multiple(errors, %{id: id, data: %{multiple: true}} = parameter, value) when not is_list(value), do: check_multiple(errors, parameter, [value])
+  defp check_multiple(errors, %{id: id, arke_id: type, data: %{ multiple: true}} = parameter, value) do
+    case check_values_type(value,type) do
+      true -> errors
+      false ->
+        errors ++ [{"[#{Enum.join(value,",")}]", "#{id} must be a list of #{type} "}]
+    end
+  end
+  defp check_multiple(errors,_parameter,_value), do: errors
+  # --- end Multiple ---
 
   defp check_whitespace(%{data: %{strip: true}} = parameter, value) when is_atom(value) do
     value
@@ -356,6 +371,7 @@ defmodule Arke.Validator do
     |> check_max(parameter, value)
     |> check_min(parameter, value)
     |> check_values(parameter, value)
+    |> check_multiple(parameter, value)
   end
 
   defp check_by_type(errors, %{arke_id: :integer, data: %{label: label}} = parameter, _value),
@@ -367,6 +383,7 @@ defmodule Arke.Validator do
     |> check_max(parameter, value)
     |> check_min(parameter, value)
     |> check_values(parameter, value)
+    |> check_multiple(parameter, value)
   end
 
   defp check_by_type(errors, %{arke_id: :float, data: %{label: label}} = parameter, _value),

lib/mix/tasks/arke.seed_project.ex

@@ -16,19 +16,6 @@ defmodule Mix.Tasks.Arke.SeedProject do
   * `--persistence` - The persistence to use. One of:
       * `arke_postgres` - via https://github.com/elixir-ecto/postgrex (Default)
   """
-  #  parameter.json
-  # add to:  arke_list,default_link {
-  ##          "id": "filter_keys",
-  ##          "metadata": {
-  ##               "default_string": ["id","arke_id"]
-  ##          }
-  ##        },
-  #  add to:  arke_or_group_id {
-  ##          "id": "filter_keys",
-  ##          "metadata": {
-  ##               "default_string": ["id","label"]
-  ##          }
-  ##        },
 
   use Mix.Task
   alias Arke.QueryManager
@@ -269,7 +256,7 @@ defmodule Mix.Tasks.Arke.SeedProject do
       nil ->  handle_parameter(t, project, parse_error(create_error(:parameter, "manager does not exists for: `#{id}`") , error))
       %Unit{} -> handle_parameter(t, project, parse_error(create_error(:parameter, "Record already exists in db for: `#{id}`") , error))
       {:error, err} ->
-        handle_parameter(t, project, parse_error(err, error))
+        handle_parameter(t, project, parse_error(err, error,id))
         _err ->
                handle_parameter(t, project, parse_error(create_error(:parameter, "Something went wrong for: `#{id}`") ,error))
     end
@@ -301,7 +288,7 @@ defmodule Mix.Tasks.Arke.SeedProject do
       if length(link_parameter_error) == 0 do
         handle_arke(t, project,  error)
         else
-        handle_arke(t, project,  [%{"parameter_error_#{id}": link_parameter_error}|error])
+        handle_arke(t, project,  [%{"#{id}_parameter_association": link_parameter_error}|error])
       end
 
     else
@@ -361,8 +348,8 @@ defmodule Mix.Tasks.Arke.SeedProject do
     end
   end
 
-  defp handle_link([current | t], project, error),
-       do: handle_link(t, project, parse_error(create_error(:link, "invalid parameters for #{current}}"),error))
+  defp handle_link([current | t], project, error),do:
+       handle_link(t, project, parse_error(create_error(:link, "invalid parameters for #{current}}"),error))
 
   defp handle_link([], _project, error), do: error
 
@@ -409,4 +396,5 @@ defmodule Mix.Tasks.Arke.SeedProject do
 
   defp parse_error(error_message, error_accumulator) when is_list(error_message), do: error_message ++error_accumulator
   defp parse_error(error_message, error_accumulator), do: [error_message | error_accumulator]
+  defp parse_error(error_message, error_accumulator,id), do: [%{create: id, error: error_message} | error_accumulator]
 end

lib/registry/arke.json

@@ -505,69 +505,9 @@
       }
     ]
   },
-  {
-    "id": "binary",
-      "label": "Binary",
-"parameters": [
-      {
-        "id": "label",
-        "metadata": {
-          "required": true
-        }
-      },
-      {
-        "id": "format",
-        "metadata": {
-          "default_string": "attribute"
-        }
-      },
-      {
-        "id": "is_primary",
-        "metadata": {
-          "default_boolean": false
-        }
-      },
-      {
-        "id": "nullable",
-        "metadata": {
-          "default_boolean": true
-        }
-      },
-      {
-        "id": "required",
-        "metadata": {
-          "default_boolean": false
-        }
-      },
-      {
-        "id": "persistence",
-        "metadata": {
-          "default_string": "arke_parameter"
-        }
-      },
-      {
-        "id": "only_run_time",
-        "metadata": {
-          "default_boolean": false
-        }
-      },
-      {
-        "id": "helper_text",
-        "metadata": {
-          "required": false
-        }
-      },
-      {
-        "id": "default_binary",
-        "metadata": {
-          "required": false
-        }
-      }
-    ]
-  },
   {
     "id": "float",
-    
+
       "label": "Float",
 "parameters": [
       {

lib/registry/parameter.json

@@ -183,7 +183,8 @@
     "multiple": false,
     "nullable": true,
     "persistence": "arke_parameter",
-    "required": false
+    "required": false,
+    "filter_keys": ["id","arke_id"]
   },
   {
     "arke_or_group_id": "arke",
@@ -200,7 +201,8 @@
     "multiple": true,
     "nullable": true,
     "persistence": "arke_parameter",
-    "required": false
+    "required": false,
+    "filter_keys": ["id","arke_id"]
   },
   {
     "connection_type": "link",
@@ -234,7 +236,9 @@
     "multiple": false,
     "nullable": false,
     "persistence": "arke_parameter",
-    "required": true
+    "required": true,
+    "filter_keys": ["id","arke_id"]
+
   },
   {
     "default_list": null,
@@ -829,7 +833,7 @@
     ]
   },
   {
-    "default_string": [],
+    "default_string": null,
     "type": "string",
     "format": "attribute",
     "helper_text": "Filter keys",