Packages
arke
0.1.2
1.1.33
retired
0.6.3
0.6.2
0.6.1
0.6.0
0.5.0
0.4.5
0.4.4
0.4.3
0.4.2
0.4.1
0.4.0
0.4.0-bulk.1
0.4.0-bulk.0
0.3.17
0.3.16
0.3.15
0.3.14
0.3.13
0.3.12
0.3.11
0.3.10
0.3.9
0.3.8
0.3.7
0.3.6
0.3.5
0.3.4
0.3.3
0.3.2
0.3.1
0.3.0
0.1.38
0.1.37
0.1.36
0.1.35
0.1.34
0.1.33
0.1.32
0.1.31
0.1.30
0.1.29
0.1.28
0.1.27
0.1.26
0.1.25
0.1.24
0.1.23
0.1.22
0.1.21
0.1.20
0.1.19
0.1.18
0.1.17
0.1.16
0.1.15
0.1.14
0.1.13
0.1.12
0.1.11
0.1.10
0.1.9
0.1.8
0.1.7
0.1.6
0.1.5
0.1.4
0.1.3
0.1.2
0.1.1
0.1.0
Arke low code framework Core
Current section
Files
Jump to
Current section
Files
lib/arke.ex
defmodule Arke do
alias Arke.Validator
alias Arke.Core.Unit
alias Arke.Boundary.{ArkeManager, GroupManager, ParameterManager}
alias Arke.Core.Parameter
def init() do
base_parameters()
GroupManager.create(
Unit.new(
:parameter,
%{label: "Parameter", description: "Parameter Group", arke_list: []},
:group,
nil,
%{},
nil,
nil,
nil
),
:arke_system
)
arke_modules = get_arke_modules()
end
defp get_arke_modules() do
Enum.reduce(:application.loaded_applications(), [], fn {app, _, _}, arke_list ->
{:ok, modules} = :application.get_key(app, :modules)
module_arke_list =
Enum.reduce(modules, [], fn mod, mod_arke_list ->
is_arke =
Code.ensure_loaded?(mod) and :erlang.function_exported(mod, :arke_from_attr, 0) and
mod.arke_from_attr != nil
mod_arke_list = check_arke_module(mod, mod_arke_list, is_arke)
end)
arke_list ++ module_arke_list
end)
end
defp check_arke_module(mod, arke_list, true) do
%{id: id, data: data, metadata: metadata} = mod.arke_from_attr
unit = Unit.new(id, data, :arke, nil, metadata, nil, nil, mod)
ArkeManager.create(unit, :arke_system)
Enum.map(mod.groups_from_attr, fn %{id: parent_id, metadata: link_metadata} ->
GroupManager.add_link(parent_id, :arke_system, :arke_list, id, link_metadata)
end)
[mod | arke_list]
end
defp check_arke_module(_, arke_list, false), do: arke_list
defp base_parameter(opts \\ []) do
%{
label: Keyword.get(opts, :label),
# type: Keyword.get!(opts, :type),
format: Keyword.get(opts, :format, :attribute),
is_primary: Keyword.get(opts, :is_primary, false),
nullable: Keyword.get(opts, :nullable, true),
required: Keyword.get(opts, :required, false),
persistence: Keyword.get(opts, :persistence, "arke_parameter"),
helper_text: Keyword.get(opts, :label, nil)
}
end
defp base_parameters() do
id =
Unit.new(
:id,
Map.merge(
base_parameter(
label: "Id",
is_primary: true,
nullable: false,
required: true,
persistence: "table_column"
),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: true,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
arke_id =
Unit.new(
:arke_id,
Map.merge(
base_parameter(
label: "Arke id",
nullable: false,
required: true,
persistence: "table_column"
),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
metadata =
Unit.new(
:metadata,
Map.merge(
base_parameter(label: "Metadata", persistence: "table_column"),
%{default_dict: %{}}
),
:dict,
nil,
%{},
nil,
nil,
nil
)
configuration =
Unit.new(
:configuration,
Map.merge(
base_parameter(label: "Configuration", persistence: "table_column"),
%{default_dict: %{}}
),
:dict,
nil,
%{},
nil,
nil,
nil
)
inserted_at =
Unit.new(
:inserted_at,
Map.merge(
base_parameter(label: "Inserted at", persistence: "table_column"),
%{default_datetime: nil}
),
:datetime,
nil,
%{},
nil,
nil,
nil
)
updated_at =
Unit.new(
:updated_at,
Map.merge(
base_parameter(label: "Updated at", persistence: "table_column"),
%{default_datetime: nil}
),
:datetime,
nil,
%{},
nil,
nil,
nil
)
active =
Unit.new(
:active,
Map.merge(
base_parameter(label: "Active", nullable: false),
%{default_boolean: true}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
label =
Unit.new(
:label,
Map.merge(
base_parameter(label: "Label", nullable: false, required: true),
%{
min_length: 2,
max_length: 200,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
format =
Unit.new(
:format,
Map.merge(
base_parameter(label: "Format", nullable: false),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: "attribute"
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
is_primary =
Unit.new(
:is_primary,
Map.merge(
base_parameter(label: "Is Primary", nullable: false),
%{default_boolean: false}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
nullable =
Unit.new(
:nullable,
Map.merge(
base_parameter(label: "Nullable", nullable: false),
%{default_boolean: true}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
required =
Unit.new(
:required,
Map.merge(
base_parameter(label: "Required", nullable: false),
%{default_boolean: false}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
persistence =
Unit.new(
:persistence,
Map.merge(
base_parameter(label: "Persistence", nullable: false),
%{
min_length: 2,
max_length: nil,
values: [
%{label: "Arke Parameter", value: "arke_parameter"},
%{label: "Table Column", value: "table_column"}
],
multiple: false,
unique: false,
default_string: "arke_parameter"
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
helper_text =
Unit.new(
:helper_text,
Map.merge(
base_parameter(label: "Helper text", nullable: true),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
min_length =
Unit.new(
:min_length,
Map.merge(
base_parameter(label: "Min Length"),
%{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}
),
:integer,
nil,
%{},
nil,
nil,
nil
)
max_length =
Unit.new(
:max_length,
Map.merge(
base_parameter(label: "Max Length"),
%{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}
),
:integer,
nil,
%{},
nil,
nil,
nil
)
values =
Unit.new(
:values,
Map.merge(
base_parameter(label: "Values"),
%{default_list: nil}
),
:list,
nil,
%{},
nil,
nil,
nil
)
multiple =
Unit.new(
:multiple,
Map.merge(
base_parameter(label: "Multiple", nullable: false),
%{default_boolean: false}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
unique =
Unit.new(
:unique,
Map.merge(
base_parameter(label: "Unique", nullable: false),
%{default_boolean: false}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
min =
Unit.new(
:min,
Map.merge(
base_parameter(label: "Min"),
%{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}
),
:integer,
nil,
%{},
nil,
nil,
nil
)
max =
Unit.new(
:max,
Map.merge(
base_parameter(label: "Max"),
%{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}
),
:integer,
nil,
%{},
nil,
nil,
nil
)
default_integer =
Unit.new(
:default_integer,
Map.merge(
base_parameter(label: "Default"),
%{min: nil, max: nil, values: nil, multiple: false, unique: false, default_integer: nil}
),
:integer,
nil,
%{},
nil,
nil,
nil
)
default_float =
Unit.new(
:default_float,
Map.merge(
base_parameter(label: "Default"),
%{min: nil, max: nil, values: nil, multiple: false, unique: false, default_float: nil}
),
:float,
nil,
%{},
nil,
nil,
nil
)
default_string =
Unit.new(
:default_string,
Map.merge(
base_parameter(label: "Default"),
%{
min_length: nil,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
default_boolean =
Unit.new(
:default_boolean,
Map.merge(
base_parameter(label: "Default"),
%{default_boolean: nil}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
default_dict =
Unit.new(
:default_dict,
Map.merge(
base_parameter(label: "Default"),
%{default_dict: nil}
),
:dict,
nil,
%{},
nil,
nil,
nil
)
default_list =
Unit.new(
:default_list,
Map.merge(
base_parameter(label: "Default"),
%{default_list: nil}
),
:list,
nil,
%{},
nil,
nil,
nil
)
default_date =
Unit.new(
:default_date,
Map.merge(
base_parameter(label: "Default"),
%{default_date: nil}
),
:date,
nil,
%{},
nil,
nil,
nil
)
default_time =
Unit.new(
:default_time,
Map.merge(
base_parameter(label: "Default"),
%{default_time: nil}
),
:time,
nil,
%{},
nil,
nil,
nil
)
default_datetime =
Unit.new(
:default_datetime,
Map.merge(
base_parameter(label: "Default"),
%{default_datetime: nil}
),
:datetime,
nil,
%{},
nil,
nil,
nil
)
default_link =
Unit.new(
:default_link,
Map.merge(
base_parameter(label: "Default"),
%{default_link: []}
),
:link,
nil,
%{},
nil,
nil,
nil
)
description =
Unit.new(
:description,
Map.merge(
base_parameter(label: "Description"),
%{
min_length: 0,
max_length: 500,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
arke_list =
Unit.new(
:arke_list,
Map.merge(
base_parameter(label: "Arke List"),
%{default_link: []}
),
:link,
nil,
%{},
nil,
nil,
nil
)
parameters =
Unit.new(
:parameters,
Map.merge(
base_parameter(label: "Parameters"),
%{default_link: []}
),
:link,
nil,
%{},
nil,
nil,
nil
)
child_id =
Unit.new(
:child_id,
Map.merge(
base_parameter(label: "Child Id"),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
parent_id =
Unit.new(
:parent_id,
Map.merge(
base_parameter(label: "Parent Id"),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
type =
Unit.new(
:type,
Map.merge(
base_parameter(label: "Type"),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
name =
Unit.new(
:name,
Map.merge(
base_parameter(label: "Name"),
%{
min_length: 2,
max_length: 100,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
public_key =
Unit.new(
:public_key,
Map.merge(
base_parameter(label: "Public Key"),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
email =
Unit.new(
:email,
Map.merge(
base_parameter(label: "Email"),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
vat =
Unit.new(
:vat,
Map.merge(
base_parameter(label: "Vat"),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
environment =
Unit.new(
:environment,
Map.merge(
base_parameter(label: "Environment"),
%{
min_length: 2,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
username =
Unit.new(
:username,
Map.merge(
base_parameter(label: "Username"),
%{
min_length: 3,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
password_hash =
Unit.new(
:password_hash,
Map.merge(
base_parameter(label: "Password hash"),
%{
min_length: 3,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
first_name =
Unit.new(
:first_name,
Map.merge(
base_parameter(label: "First name"),
%{
min_length: 3,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
last_name =
Unit.new(
:last_name,
Map.merge(
base_parameter(label: "Last name"),
%{
min_length: 3,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
fiscal_code =
Unit.new(
:fiscal_code,
Map.merge(
base_parameter(label: "Fiscal code"),
%{
min_length: 3,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
address =
Unit.new(
:address,
Map.merge(
base_parameter(label: "Address"),
%{default_dict: nil}
),
:dict,
nil,
%{},
nil,
nil,
nil
)
phone_number =
Unit.new(
:phone_number,
Map.merge(
base_parameter(label: "Phone number"),
%{
min_length: 1,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
birth_date =
Unit.new(
:birth_date,
Map.merge(
base_parameter(label: "Birth date"),
%{
min_length: 1,
max_length: nil,
values: nil,
multiple: false,
unique: false,
default_string: nil
}
),
:string,
nil,
%{},
nil,
nil,
nil
)
first_access =
Unit.new(
:first_access,
Map.merge(
base_parameter(label: "First access"),
%{default_boolean: true}
),
:boolean,
nil,
%{},
nil,
nil,
nil
)
last_login =
Unit.new(
:last_login,
Map.merge(
base_parameter(label: "Last login", persistence: "table_column"),
%{default_datetime: nil}
),
:datetime,
nil,
%{},
nil,
nil,
nil
)
parameters = [
id,
arke_id,
metadata,
configuration,
inserted_at,
updated_at,
active,
label,
format,
is_primary,
nullable,
required,
persistence,
helper_text,
min_length,
max_length,
values,
multiple,
unique,
min,
max,
default_integer,
default_float,
default_string,
default_boolean,
default_dict,
default_list,
default_date,
default_time,
default_datetime,
description,
arke_list,
parameters,
child_id,
parent_id,
type,
name,
public_key,
email,
vat,
environment,
username,
password_hash,
first_name,
last_name,
fiscal_code,
address,
phone_number,
first_access,
last_login,
birth_date,
default_link
]
Enum.map(parameters, fn parameter ->
ParameterManager.create(parameter, :arke_system)
end)
end
end