Current section
Files
Jump to
Current section
Files
src/telega@flow@engine.erl
-module(telega@flow@engine).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/telega/flow/engine.gleam").
-export([handle_error/4, generate_wait_token/1, apply_middlewares/4, execute_subflow_step/4, execute_step/3, start_or_resume/5, resume_with_instance/4, resume_with_token/4, extract_ids_from_context/1]).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC(" Core execution engine, hooks, middleware application, and conditionals.\n").
-file("src/telega/flow/engine.gleam", 214).
?DOC(false).
-spec handle_error(
telega@flow@types:flow(any(), AOMZ, AONA),
telega@bot:context(AOMZ, AONA),
telega@flow@types:flow_instance(),
gleam@option:option(AONA)
) -> {ok, telega@bot:context(AOMZ, AONA)} | {error, AONA}.
handle_error(Flow, Ctx, Instance, Error) ->
case erlang:element(9, Flow) of
{some, Handler} ->
case Handler(Ctx, Instance, Error) of
{ok, New_ctx} ->
{ok, New_ctx};
{error, _} ->
{ok, Ctx}
end;
none ->
{ok, Ctx}
end.
-file("src/telega/flow/engine.gleam", 1061).
-spec handle_subflow_error(
telega@flow@types:flow(gleam@dynamic:dynamic_(), AOVR, AOVS),
telega@bot:context(AOVR, AOVS),
telega@flow@types:flow_instance(),
gleam@option:option(AOVS),
telega@flow@types:subflow_config(any(), AOVR, AOVS)
) -> {ok, telega@bot:context(AOVR, AOVS)} | {error, AOVS}.
handle_subflow_error(Flow, Ctx, Instance, Error, _) ->
case erlang:element(9, Flow) of
{some, Handler} ->
case Handler(Ctx, Instance, Error) of
{ok, New_ctx} ->
{ok, New_ctx};
{error, _} ->
{ok, Ctx}
end;
none ->
{ok, Ctx}
end.
-file("src/telega/flow/engine.gleam", 257).
?DOC(false).
-spec generate_wait_token(telega@flow@types:flow_instance()) -> binary().
generate_wait_token(Instance) ->
<<<<(erlang:element(2, Instance))/binary, ":"/utf8>>/binary,
(erlang:integer_to_binary(telega@internal@utils:current_time_ms()))/binary>>.
-file("src/telega/flow/engine.gleam", 1023).
-spec return_to_parent_flow(
telega@bot:context(AOVD, AOVE),
telega@flow@types:flow_instance(),
gleam@dict:dict(binary(), binary()),
telega@flow@types:subflow_config(any(), AOVD, AOVE)
) -> {ok, telega@bot:context(AOVD, AOVE)} | {error, AOVE}.
return_to_parent_flow(Ctx, Instance, Result, Config) ->
case erlang:element(5, erlang:element(6, Instance)) of
[Frame | Rest_stack] ->
Temp_instance = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record = erlang:element(6, Instance),
{flow_state,
erlang:element(2, _record),
erlang:element(4, Frame),
erlang:element(4, _record),
erlang:element(5, _record),
erlang:element(6, _record)}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
erlang:element(11, Instance)},
Mapped_instance = (erlang:element(6, Config))(Result, Temp_instance),
Updated_instance = {flow_instance,
erlang:element(2, Mapped_instance),
erlang:element(2, Frame),
erlang:element(4, Mapped_instance),
erlang:element(5, Mapped_instance),
begin
_record@1 = erlang:element(6, Mapped_instance),
{flow_state,
erlang:element(3, Frame),
erlang:element(3, _record@1),
[erlang:element(3, Frame) |
erlang:element(
4,
erlang:element(6, Mapped_instance)
)],
Rest_stack,
erlang:element(6, _record@1)}
end,
maps:new(),
erlang:element(8, Mapped_instance),
erlang:element(9, Mapped_instance),
erlang:element(10, Mapped_instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(
2,
erlang:element(7, erlang:element(3, Config))
))(Updated_instance) of
{ok, _} ->
{ok, Ctx};
{error, _} ->
{ok, Ctx}
end;
[] ->
{ok, Ctx}
end.
-file("src/telega/flow/engine.gleam", 239).
?DOC(false).
-spec apply_middlewares(
telega@bot:context(AONP, AONQ),
telega@flow@types:flow_instance(),
fun(() -> {ok,
{telega@bot:context(AONP, AONQ),
telega@flow@types:flow_action(AONT),
telega@flow@types:flow_instance()}} |
{error, AONQ}),
list(fun((telega@bot:context(AONP, AONQ), telega@flow@types:flow_instance(), fun(() -> {ok,
{telega@bot:context(AONP, AONQ),
telega@flow@types:flow_action(AONT),
telega@flow@types:flow_instance()}} |
{error, AONQ})) -> {ok,
{telega@bot:context(AONP, AONQ),
telega@flow@types:flow_action(AONT),
telega@flow@types:flow_instance()}} |
{error, AONQ}))
) -> {ok,
{telega@bot:context(AONP, AONQ),
telega@flow@types:flow_action(AONT),
telega@flow@types:flow_instance()}} |
{error, AONQ}.
apply_middlewares(Ctx, Instance, Handler, Middlewares) ->
case Middlewares of
[] ->
Handler();
[Middleware | Rest] ->
Middleware(
Ctx,
Instance,
fun() -> apply_middlewares(Ctx, Instance, Handler, Rest) end
)
end.
-file("src/telega/flow/engine.gleam", 876).
-spec process_subflow_action(
telega@flow@types:flow(gleam@dynamic:dynamic_(), AOUN, AOUO),
telega@bot:context(AOUN, AOUO),
telega@flow@types:flow_action(gleam@dynamic:dynamic_()),
telega@flow@types:flow_instance(),
telega@flow@types:subflow_config(any(), AOUN, AOUO)
) -> {ok, telega@bot:context(AOUN, AOUO)} | {error, AOUO}.
process_subflow_action(Flow, Ctx, Action, Instance, Config) ->
case Action of
{complete, Data} ->
return_to_parent_flow(Ctx, Instance, Data, Config);
{exit, {some, Data}} ->
return_to_parent_flow(Ctx, Instance, Data, Config);
{exit, none} ->
return_to_parent_flow(
Ctx,
Instance,
erlang:element(3, erlang:element(6, Instance)),
Config
);
{return_from_subflow, Result} ->
return_to_parent_flow(Ctx, Instance, Result, Config);
cancel ->
_ = (erlang:element(4, erlang:element(7, Flow)))(
erlang:element(2, Instance)
),
{ok, Ctx};
{next, Step} ->
Step_name = (erlang:element(5, Flow))(Step),
Updated_instance = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record = erlang:element(6, Instance),
{flow_state,
Step_name,
erlang:element(3, _record),
[erlang:element(2, erlang:element(6, Instance)) |
erlang:element(4, erlang:element(6, Instance))],
erlang:element(5, _record),
erlang:element(6, _record)}
end,
gleam@dict:delete(
erlang:element(7, Instance),
<<"__wait_result"/utf8>>
),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(Updated_instance) of
{ok, _} ->
execute_subflow_step(Flow, Ctx, Updated_instance, Config);
{error, Err} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err},
Config
)
end;
{next_string, Step_name@1} ->
Updated_instance@1 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@1 = erlang:element(6, Instance),
{flow_state,
Step_name@1,
erlang:element(3, _record@1),
[erlang:element(2, erlang:element(6, Instance)) |
erlang:element(4, erlang:element(6, Instance))],
erlang:element(5, _record@1),
erlang:element(6, _record@1)}
end,
gleam@dict:delete(
erlang:element(7, Instance),
<<"__wait_result"/utf8>>
),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@1
) of
{ok, _} ->
execute_subflow_step(Flow, Ctx, Updated_instance@1, Config);
{error, Err@1} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err@1},
Config
)
end;
{go_to, Step@1} ->
Step_name@2 = (erlang:element(5, Flow))(Step@1),
Updated_instance@2 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
{flow_state,
Step_name@2,
erlang:element(3, erlang:element(6, Instance)),
[Step_name@2],
erlang:element(5, erlang:element(6, Instance)),
none},
maps:new(),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@2
) of
{ok, _} ->
execute_subflow_step(Flow, Ctx, Updated_instance@2, Config);
{error, Err@2} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err@2},
Config
)
end;
back ->
case erlang:element(4, erlang:element(6, Instance)) of
[Previous_step | Rest] ->
Updated_instance@3 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@2 = erlang:element(6, Instance),
{flow_state,
Previous_step,
erlang:element(3, _record@2),
Rest,
erlang:element(5, _record@2),
erlang:element(6, _record@2)}
end,
gleam@dict:delete(
erlang:element(7, Instance),
<<"__wait_result"/utf8>>
),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@3
) of
{ok, _} ->
execute_subflow_step(
Flow,
Ctx,
Updated_instance@3,
Config
);
{error, Err@3} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err@3},
Config
)
end;
[] ->
{ok, Ctx}
end;
wait ->
Token = generate_wait_token(Instance),
Updated_instance@4 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token},
none,
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@4
) of
{ok, _} ->
{ok, Ctx};
{error, Err@4} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err@4},
Config
)
end;
wait_callback ->
Token = generate_wait_token(Instance),
Updated_instance@4 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token},
none,
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@4
) of
{ok, _} ->
{ok, Ctx};
{error, Err@4} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err@4},
Config
)
end;
{wait_with_timeout, Timeout_ms} ->
Token@1 = generate_wait_token(Instance),
Wait_timeout_at = telega@internal@utils:current_time_ms() + Timeout_ms,
Updated_instance@5 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token@1},
{some, Wait_timeout_at},
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@5
) of
{ok, _} ->
{ok, Ctx};
{error, Err@5} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err@5},
Config
)
end;
{wait_callback_with_timeout, Timeout_ms} ->
Token@1 = generate_wait_token(Instance),
Wait_timeout_at = telega@internal@utils:current_time_ms() + Timeout_ms,
Updated_instance@5 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token@1},
{some, Wait_timeout_at},
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@5
) of
{ok, _} ->
{ok, Ctx};
{error, Err@5} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err@5},
Config
)
end;
{start_parallel, _, _} ->
{ok, Ctx};
{complete_parallel_step, _, _} ->
{ok, Ctx};
{enter_subflow, _, _} ->
{ok, Ctx}
end.
-file("src/telega/flow/engine.gleam", 849).
?DOC(false).
-spec execute_subflow_step(
telega@flow@types:flow(gleam@dynamic:dynamic_(), AOTY, AOTZ),
telega@bot:context(AOTY, AOTZ),
telega@flow@types:flow_instance(),
telega@flow@types:subflow_config(any(), AOTY, AOTZ)
) -> {ok, telega@bot:context(AOTY, AOTZ)} | {error, AOTZ}.
execute_subflow_step(Flow, Ctx, Instance, Config) ->
case gleam_stdlib:map_get(
erlang:element(3, Flow),
erlang:element(2, erlang:element(6, Instance))
) of
{ok, Step_config} ->
Handler_fn = fun() ->
(erlang:element(2, Step_config))(Ctx, Instance)
end,
Result = apply_middlewares(
Ctx,
Instance,
Handler_fn,
lists:append(
erlang:element(10, Flow),
erlang:element(3, Step_config)
)
),
case Result of
{ok, {New_ctx, Action, New_instance}} ->
process_subflow_action(
Flow,
New_ctx,
Action,
New_instance,
Config
);
{error, Err} ->
handle_subflow_error(
Flow,
Ctx,
Instance,
{some, Err},
Config
)
end;
{error, _} ->
handle_subflow_error(Flow, Ctx, Instance, none, Config)
end.
-file("src/telega/flow/engine.gleam", 670).
-spec run_flow_exit_hook(
gleam@option:option(fun((telega@bot:context(AOQZ, AORA), telega@flow@types:flow_instance()) -> {ok,
telega@bot:context(AOQZ, AORA)} |
{error, AORA})),
telega@bot:context(AOQZ, AORA),
telega@flow@types:flow_instance()
) -> {ok, telega@bot:context(AOQZ, AORA)} | {error, AORA}.
run_flow_exit_hook(Hook, Ctx, Instance) ->
case Hook of
{some, Exit_fn} ->
Exit_fn(Ctx, Instance);
none ->
{ok, Ctx}
end.
-file("src/telega/flow/engine.gleam", 822).
-spec merge_parallel_results(
gleam@dict:dict(binary(), binary()),
gleam@dict:dict(binary(), gleam@dict:dict(binary(), binary()))
) -> gleam@dict:dict(binary(), binary()).
merge_parallel_results(Base_data, Parallel_results) ->
gleam@dict:fold(
Parallel_results,
Base_data,
fun(Acc, Step_name, Step_results) ->
gleam@dict:fold(
Step_results,
Acc,
fun(Inner_acc, Key, Value) ->
gleam@dict:insert(
Inner_acc,
<<<<Step_name/binary, "."/utf8>>/binary, Key/binary>>,
Value
)
end
)
end
).
-file("src/telega/flow/engine.gleam", 637).
-spec run_leave_hook(
gleam@option:option(fun((telega@bot:context(AOPS, AOPT), telega@flow@types:flow_instance()) -> {ok,
{telega@bot:context(AOPS, AOPT), telega@flow@types:flow_instance()}} |
{error, AOPT})),
telega@bot:context(AOPS, AOPT),
telega@flow@types:flow_instance()
) -> {ok, {telega@bot:context(AOPS, AOPT), telega@flow@types:flow_instance()}} |
{error, AOPT}.
run_leave_hook(Hook, Ctx, Instance) ->
case Hook of
{some, Leave_fn} ->
Leave_fn(Ctx, Instance);
none ->
{ok, {Ctx, Instance}}
end.
-file("src/telega/flow/engine.gleam", 626).
-spec run_enter_hook(
gleam@option:option(fun((telega@bot:context(AOPH, AOPI), telega@flow@types:flow_instance()) -> {ok,
{telega@bot:context(AOPH, AOPI), telega@flow@types:flow_instance()}} |
{error, AOPI})),
telega@bot:context(AOPH, AOPI),
telega@flow@types:flow_instance()
) -> {ok, {telega@bot:context(AOPH, AOPI), telega@flow@types:flow_instance()}} |
{error, AOPI}.
run_enter_hook(Hook, Ctx, Instance) ->
case Hook of
{some, Enter_fn} ->
Enter_fn(Ctx, Instance);
none ->
{ok, {Ctx, Instance}}
end.
-file("src/telega/flow/engine.gleam", 659).
-spec run_flow_leave_hook(
gleam@option:option(fun((telega@bot:context(AOQO, AOQP), telega@flow@types:flow_instance()) -> {ok,
{telega@bot:context(AOQO, AOQP), telega@flow@types:flow_instance()}} |
{error, AOQP})),
telega@bot:context(AOQO, AOQP),
telega@flow@types:flow_instance()
) -> {ok, {telega@bot:context(AOQO, AOQP), telega@flow@types:flow_instance()}} |
{error, AOQP}.
run_flow_leave_hook(Hook, Ctx, Instance) ->
case Hook of
{some, Leave_fn} ->
Leave_fn(Ctx, Instance);
none ->
{ok, {Ctx, Instance}}
end.
-file("src/telega/flow/engine.gleam", 732).
-spec start_subflow_execution(
telega@flow@types:flow(AOSJ, AOSK, AOSL),
telega@bot:context(AOSK, AOSL),
telega@flow@types:flow_instance(),
telega@flow@types:subflow_config(AOSJ, AOSK, AOSL)
) -> {ok, telega@bot:context(AOSK, AOSL)} | {error, AOSL}.
start_subflow_execution(Parent_flow, Ctx, Instance, Config) ->
case run_flow_leave_hook(erlang:element(15, Parent_flow), Ctx, Instance) of
{ok, {Ctx_after_leave, Instance_after_leave}} ->
Return_step = (erlang:element(5, Parent_flow))(
erlang:element(4, Config)
),
Stack_frame = {flow_stack_frame,
erlang:element(2, Parent_flow),
Return_step,
erlang:element(3, erlang:element(6, Instance_after_leave))},
Subflow_data = (erlang:element(5, Config))(Instance_after_leave),
Subflow_initial_step = (erlang:element(5, erlang:element(3, Config)))(
erlang:element(4, erlang:element(3, Config))
),
Updated_instance = {flow_instance,
erlang:element(2, Instance_after_leave),
erlang:element(2, erlang:element(3, Config)),
erlang:element(4, Instance_after_leave),
erlang:element(5, Instance_after_leave),
{flow_state,
Subflow_initial_step,
Subflow_data,
[Subflow_initial_step],
[Stack_frame |
erlang:element(
5,
erlang:element(6, Instance_after_leave)
)],
none},
maps:new(),
erlang:element(8, Instance_after_leave),
erlang:element(9, Instance_after_leave),
erlang:element(10, Instance_after_leave),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Parent_flow)))(
Updated_instance
) of
{ok, _} ->
execute_subflow_step(
erlang:element(3, Config),
Ctx_after_leave,
Updated_instance,
Config
);
{error, Err} ->
handle_error(Parent_flow, Ctx, Instance, {some, Err})
end;
{error, Err@1} ->
handle_error(Parent_flow, Ctx, Instance, {some, Err@1})
end.
-file("src/telega/flow/engine.gleam", 722).
-spec check_subflow_trigger(
telega@flow@types:flow(AORZ, AOSA, AOSB),
telega@flow@types:flow_instance()
) -> gleam@option:option(telega@flow@types:subflow_config(AORZ, AOSA, AOSB)).
check_subflow_trigger(Flow, Instance) ->
_pipe = gleam@list:find(
erlang:element(13, Flow),
fun(Config) ->
erlang:element(2, Config) =:= erlang:element(
2,
erlang:element(6, Instance)
)
end
),
gleam@option:from_result(_pipe).
-file("src/telega/flow/engine.gleam", 712).
-spec check_parallel_trigger(
telega@flow@types:flow(AORR, any(), any()),
telega@flow@types:flow_instance()
) -> gleam@option:option(telega@flow@types:parallel_config(AORR)).
check_parallel_trigger(Flow, Instance) ->
_pipe = gleam@list:find(
erlang:element(12, Flow),
fun(Config) ->
erlang:element(2, Config) =:= erlang:element(
2,
erlang:element(6, Instance)
)
end
),
gleam@option:from_result(_pipe).
-file("src/telega/flow/engine.gleam", 681).
-spec check_conditionals(
telega@flow@types:flow(any(), any(), any()),
telega@flow@types:flow_instance()
) -> gleam@option:option(binary()).
check_conditionals(Flow, Instance) ->
gleam@list:fold(
erlang:element(11, Flow),
none,
fun(Acc, Conditional) -> case Acc of
{some, _} ->
Acc;
none ->
case erlang:element(2, Conditional) =:= erlang:element(
2,
erlang:element(6, Instance)
) of
true ->
_pipe = gleam@list:fold(
erlang:element(3, Conditional),
none,
fun(Inner_acc, Cond) -> case Inner_acc of
{some, _} ->
Inner_acc;
none ->
{Check_fn, Step} = Cond,
case Check_fn(Instance) of
true ->
{some,
(erlang:element(5, Flow))(
Step
)};
false ->
none
end
end end
),
gleam@option:'or'(
_pipe,
{some,
(erlang:element(5, Flow))(
erlang:element(4, Conditional)
)}
);
false ->
none
end
end end
).
-file("src/telega/flow/engine.gleam", 282).
-spec process_action(
telega@flow@types:flow(AOOU, AOOV, AOOW),
telega@bot:context(AOOV, AOOW),
telega@flow@types:flow_action(AOOU),
telega@flow@types:flow_instance()
) -> {ok, telega@bot:context(AOOV, AOOW)} | {error, AOOW}.
process_action(Flow, Ctx, Action, Instance) ->
case Action of
{next, Step} ->
Step_name = (erlang:element(5, Flow))(Step),
Updated_instance = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record = erlang:element(6, Instance),
{flow_state,
Step_name,
erlang:element(3, _record),
[erlang:element(2, erlang:element(6, Instance)) |
erlang:element(4, erlang:element(6, Instance))],
erlang:element(5, _record),
erlang:element(6, _record)}
end,
gleam@dict:delete(
erlang:element(7, Instance),
<<"__wait_result"/utf8>>
),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(Updated_instance) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance);
{error, Err} ->
handle_error(Flow, Ctx, Instance, {some, Err})
end;
{next_string, Step_name@1} ->
Updated_instance@1 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@1 = erlang:element(6, Instance),
{flow_state,
Step_name@1,
erlang:element(3, _record@1),
[erlang:element(2, erlang:element(6, Instance)) |
erlang:element(4, erlang:element(6, Instance))],
erlang:element(5, _record@1),
erlang:element(6, _record@1)}
end,
gleam@dict:delete(
erlang:element(7, Instance),
<<"__wait_result"/utf8>>
),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@1
) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance@1);
{error, Err@1} ->
handle_error(Flow, Ctx, Instance, {some, Err@1})
end;
{return_from_subflow, Result} ->
case erlang:element(5, erlang:element(6, Instance)) of
[Frame | Rest_stack] ->
Updated_instance@2 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@2 = erlang:element(6, Instance),
{flow_state,
erlang:element(3, Frame),
maps:merge(
erlang:element(
3,
erlang:element(6, Instance)
),
Result
),
erlang:element(4, _record@2),
Rest_stack,
erlang:element(6, _record@2)}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@2
) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance@2);
{error, Err@2} ->
handle_error(Flow, Ctx, Instance, {some, Err@2})
end;
[] ->
{ok, Ctx}
end;
{start_parallel, Steps, Join_at} ->
Step_names = gleam@list:map(Steps, erlang:element(5, Flow)),
Join_step_name = (erlang:element(5, Flow))(Join_at),
Parallel_state = {parallel_state,
Step_names,
[],
maps:new(),
Join_step_name},
Updated_instance@3 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@3 = erlang:element(6, Instance),
{flow_state,
erlang:element(2, _record@3),
erlang:element(3, _record@3),
erlang:element(4, _record@3),
erlang:element(5, _record@3),
{some, Parallel_state}}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@3
) of
{ok, _} ->
case Step_names of
[First | _] ->
Step_instance = {flow_instance,
erlang:element(2, Updated_instance@3),
erlang:element(3, Updated_instance@3),
erlang:element(4, Updated_instance@3),
erlang:element(5, Updated_instance@3),
begin
_record@4 = erlang:element(
6,
Updated_instance@3
),
{flow_state,
First,
erlang:element(3, _record@4),
erlang:element(4, _record@4),
erlang:element(5, _record@4),
erlang:element(6, _record@4)}
end,
erlang:element(7, Updated_instance@3),
erlang:element(8, Updated_instance@3),
erlang:element(9, Updated_instance@3),
erlang:element(10, Updated_instance@3),
erlang:element(11, Updated_instance@3)},
execute_step(Flow, Ctx, Step_instance);
[] ->
{ok, Ctx}
end;
{error, Err@3} ->
handle_error(Flow, Ctx, Instance, {some, Err@3})
end;
{complete_parallel_step, Step@1, Result@1} ->
case erlang:element(6, erlang:element(6, Instance)) of
{some, Parallel_state@1} ->
Step_name@2 = (erlang:element(5, Flow))(Step@1),
Updated_parallel = {parallel_state,
gleam@list:filter(
erlang:element(2, Parallel_state@1),
fun(S) -> S /= Step_name@2 end
),
[Step_name@2 | erlang:element(3, Parallel_state@1)],
gleam@dict:insert(
erlang:element(4, Parallel_state@1),
Step_name@2,
Result@1
),
erlang:element(5, Parallel_state@1)},
case erlang:element(2, Updated_parallel) of
[] ->
Updated_instance@4 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@5 = erlang:element(6, Instance),
{flow_state,
erlang:element(5, Updated_parallel),
merge_parallel_results(
erlang:element(
3,
erlang:element(6, Instance)
),
erlang:element(4, Updated_parallel)
),
erlang:element(4, _record@5),
erlang:element(5, _record@5),
none}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@4
) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance@4);
{error, Err@4} ->
handle_error(
Flow,
Ctx,
Instance,
{some, Err@4}
)
end;
[Next | _] ->
Updated_instance@5 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@6 = erlang:element(6, Instance),
{flow_state,
Next,
erlang:element(3, _record@6),
erlang:element(4, _record@6),
erlang:element(5, _record@6),
{some, Updated_parallel}}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@5
) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance@5);
{error, Err@5} ->
handle_error(
Flow,
Ctx,
Instance,
{some, Err@5}
)
end
end;
none ->
{ok, Ctx}
end;
{go_to, Step@2} ->
Step_name@3 = (erlang:element(5, Flow))(Step@2),
Updated_instance@6 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
{flow_state,
Step_name@3,
erlang:element(3, erlang:element(6, Instance)),
[Step_name@3],
[],
none},
maps:new(),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@6
) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance@6);
{error, Err@6} ->
handle_error(Flow, Ctx, Instance, {some, Err@6})
end;
back ->
case erlang:element(4, erlang:element(6, Instance)) of
[Previous_step | Rest] ->
Updated_instance@7 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@7 = erlang:element(6, Instance),
{flow_state,
Previous_step,
erlang:element(3, _record@7),
Rest,
erlang:element(5, _record@7),
erlang:element(6, _record@7)}
end,
gleam@dict:delete(
erlang:element(7, Instance),
<<"__wait_result"/utf8>>
),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@7
) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance@7);
{error, Err@7} ->
handle_error(Flow, Ctx, Instance, {some, Err@7})
end;
[] ->
{ok, Ctx}
end;
{complete, Data} ->
Completed_instance = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record@8 = erlang:element(6, Instance),
{flow_state,
erlang:element(2, _record@8),
Data,
erlang:element(4, _record@8),
erlang:element(5, _record@8),
erlang:element(6, _record@8)}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
erlang:element(11, Instance)},
case erlang:element(8, Flow) of
{some, Handler} ->
case Handler(Ctx, Completed_instance) of
{ok, New_ctx} ->
case run_flow_exit_hook(
erlang:element(16, Flow),
New_ctx,
Completed_instance
) of
{ok, Final_ctx} ->
_ = (erlang:element(
4,
erlang:element(7, Flow)
))(erlang:element(2, Instance)),
{ok, Final_ctx};
{error, Err@8} ->
handle_error(
Flow,
Ctx,
Instance,
{some, Err@8}
)
end;
{error, Err@9} ->
handle_error(Flow, Ctx, Instance, {some, Err@9})
end;
none ->
case run_flow_exit_hook(
erlang:element(16, Flow),
Ctx,
Completed_instance
) of
{ok, Final_ctx@1} ->
_ = (erlang:element(4, erlang:element(7, Flow)))(
erlang:element(2, Instance)
),
{ok, Final_ctx@1};
{error, Err@10} ->
handle_error(Flow, Ctx, Instance, {some, Err@10})
end
end;
cancel ->
case run_flow_exit_hook(erlang:element(16, Flow), Ctx, Instance) of
{ok, Final_ctx@2} ->
_ = (erlang:element(4, erlang:element(7, Flow)))(
erlang:element(2, Instance)
),
{ok, Final_ctx@2};
{error, Err@11} ->
handle_error(Flow, Ctx, Instance, {some, Err@11})
end;
wait ->
Token = generate_wait_token(Instance),
Updated_instance@8 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token},
none,
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@8
) of
{ok, _} ->
{ok, Ctx};
{error, Err@12} ->
handle_error(Flow, Ctx, Instance, {some, Err@12})
end;
wait_callback ->
Token = generate_wait_token(Instance),
Updated_instance@8 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token},
none,
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@8
) of
{ok, _} ->
{ok, Ctx};
{error, Err@12} ->
handle_error(Flow, Ctx, Instance, {some, Err@12})
end;
{wait_with_timeout, Timeout_ms} ->
Token@1 = generate_wait_token(Instance),
Wait_timeout_at = telega@internal@utils:current_time_ms() + Timeout_ms,
Updated_instance@9 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token@1},
{some, Wait_timeout_at},
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@9
) of
{ok, _} ->
{ok, Ctx};
{error, Err@13} ->
handle_error(Flow, Ctx, Instance, {some, Err@13})
end;
{wait_callback_with_timeout, Timeout_ms} ->
Token@1 = generate_wait_token(Instance),
Wait_timeout_at = telega@internal@utils:current_time_ms() + Timeout_ms,
Updated_instance@9 = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
{some, Token@1},
{some, Wait_timeout_at},
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@9
) of
{ok, _} ->
{ok, Ctx};
{error, Err@13} ->
handle_error(Flow, Ctx, Instance, {some, Err@13})
end;
{exit, _} ->
_ = (erlang:element(4, erlang:element(7, Flow)))(
erlang:element(2, Instance)
),
{ok, Ctx};
{enter_subflow, Subflow_name, Data@1} ->
case gleam@list:find(
erlang:element(13, Flow),
fun(Config) ->
erlang:element(2, erlang:element(3, Config)) =:= Subflow_name
end
) of
{ok, Subflow_config} ->
Return_step = (erlang:element(5, Flow))(
erlang:element(4, Subflow_config)
),
Stack_frame = {flow_stack_frame,
erlang:element(2, Flow),
Return_step,
erlang:element(3, erlang:element(6, Instance))},
Subflow_initial_step = (erlang:element(
5,
erlang:element(3, Subflow_config)
))(erlang:element(4, erlang:element(3, Subflow_config))),
Updated_instance@10 = {flow_instance,
erlang:element(2, Instance),
erlang:element(2, erlang:element(3, Subflow_config)),
erlang:element(4, Instance),
erlang:element(5, Instance),
{flow_state,
Subflow_initial_step,
maps:merge(
erlang:element(3, erlang:element(6, Instance)),
Data@1
),
[Subflow_initial_step],
[Stack_frame |
erlang:element(5, erlang:element(6, Instance))],
none},
maps:new(),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(
Updated_instance@10
) of
{ok, _} ->
execute_subflow_step(
erlang:element(3, Subflow_config),
Ctx,
Updated_instance@10,
Subflow_config
);
{error, Err@14} ->
handle_error(Flow, Ctx, Instance, {some, Err@14})
end;
{error, _} ->
{ok, Ctx}
end
end.
-file("src/telega/flow/engine.gleam", 262).
?DOC(" Process action with leave hook support\n").
-spec process_action_with_leave_hook(
telega@flow@types:flow(AOOE, AOOF, AOOG),
telega@bot:context(AOOF, AOOG),
telega@flow@types:flow_action(AOOE),
telega@flow@types:flow_instance(),
gleam@option:option(fun((telega@bot:context(AOOF, AOOG), telega@flow@types:flow_instance()) -> {ok,
{telega@bot:context(AOOF, AOOG), telega@flow@types:flow_instance()}} |
{error, AOOG}))
) -> {ok, telega@bot:context(AOOF, AOOG)} | {error, AOOG}.
process_action_with_leave_hook(Flow, Ctx, Action, Instance, Leave_hook) ->
case Action of
wait ->
process_action(Flow, Ctx, Action, Instance);
wait_callback ->
process_action(Flow, Ctx, Action, Instance);
{wait_with_timeout, _} ->
process_action(Flow, Ctx, Action, Instance);
{wait_callback_with_timeout, _} ->
process_action(Flow, Ctx, Action, Instance);
_ ->
case run_leave_hook(Leave_hook, Ctx, Instance) of
{ok, {Ctx_after_leave, Instance_after_leave}} ->
process_action(
Flow,
Ctx_after_leave,
Action,
Instance_after_leave
);
{error, Err} ->
handle_error(Flow, Ctx, Instance, {some, Err})
end
end.
-file("src/telega/flow/engine.gleam", 783).
-spec start_parallel_execution(
telega@flow@types:flow(AOSY, AOSZ, AOTA),
telega@bot:context(AOSZ, AOTA),
telega@flow@types:flow_instance(),
telega@flow@types:parallel_config(AOSY)
) -> {ok, telega@bot:context(AOSZ, AOTA)} | {error, AOTA}.
start_parallel_execution(Flow, Ctx, Instance, Config) ->
Pending_steps = gleam@list:map(
erlang:element(3, Config),
erlang:element(5, Flow)
),
Join_step = (erlang:element(5, Flow))(erlang:element(4, Config)),
Parallel_state = {parallel_state, Pending_steps, [], maps:new(), Join_step},
Updated_instance = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record = erlang:element(6, Instance),
{flow_state,
erlang:element(2, _record),
erlang:element(3, _record),
erlang:element(4, _record),
erlang:element(5, _record),
{some, Parallel_state}}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(Updated_instance) of
{ok, _} ->
case Pending_steps of
[Current_step | _] ->
Step_instance = {flow_instance,
erlang:element(2, Updated_instance),
erlang:element(3, Updated_instance),
erlang:element(4, Updated_instance),
erlang:element(5, Updated_instance),
begin
_record@1 = erlang:element(6, Updated_instance),
{flow_state,
Current_step,
erlang:element(3, _record@1),
erlang:element(4, _record@1),
erlang:element(5, _record@1),
erlang:element(6, _record@1)}
end,
erlang:element(7, Updated_instance),
erlang:element(8, Updated_instance),
erlang:element(9, Updated_instance),
erlang:element(10, Updated_instance),
erlang:element(11, Updated_instance)},
execute_step(Flow, Ctx, Step_instance);
[] ->
{ok, Ctx}
end;
{error, Err} ->
handle_error(Flow, Ctx, Instance, {some, Err})
end.
-file("src/telega/flow/engine.gleam", 136).
?DOC(false).
-spec execute_step(
telega@flow@types:flow(any(), AOMN, AOMO),
telega@bot:context(AOMN, AOMO),
telega@flow@types:flow_instance()
) -> {ok, telega@bot:context(AOMN, AOMO)} | {error, AOMO}.
execute_step(Flow, Ctx, Instance) ->
case check_conditionals(Flow, Instance) of
{some, Next_step} ->
Updated_instance = {flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
begin
_record = erlang:element(6, Instance),
{flow_state,
Next_step,
erlang:element(3, _record),
[erlang:element(2, erlang:element(6, Instance)) |
erlang:element(4, erlang:element(6, Instance))],
erlang:element(5, _record),
erlang:element(6, _record)}
end,
erlang:element(7, Instance),
erlang:element(8, Instance),
erlang:element(9, Instance),
erlang:element(10, Instance),
telega@internal@utils:current_time_ms()},
case (erlang:element(2, erlang:element(7, Flow)))(Updated_instance) of
{ok, _} ->
execute_step(Flow, Ctx, Updated_instance);
{error, Err} ->
handle_error(Flow, Ctx, Instance, {some, Err})
end;
none ->
case check_parallel_trigger(Flow, Instance) of
{some, Config} ->
start_parallel_execution(Flow, Ctx, Instance, Config);
none ->
case check_subflow_trigger(Flow, Instance) of
{some, Subflow_config} ->
start_subflow_execution(
Flow,
Ctx,
Instance,
Subflow_config
);
none ->
case gleam_stdlib:map_get(
erlang:element(3, Flow),
erlang:element(2, erlang:element(6, Instance))
) of
{ok, Config@1} ->
case run_enter_hook(
erlang:element(4, Config@1),
Ctx,
Instance
) of
{ok,
{Ctx_after_enter,
Instance_after_enter}} ->
Handler_fn = fun() ->
(erlang:element(2, Config@1))(
Ctx_after_enter,
Instance_after_enter
)
end,
Result = apply_middlewares(
Ctx_after_enter,
Instance_after_enter,
Handler_fn,
lists:append(
erlang:element(10, Flow),
erlang:element(3, Config@1)
)
),
case Result of
{ok,
{New_ctx,
Action,
New_instance}} ->
process_action_with_leave_hook(
Flow,
New_ctx,
Action,
New_instance,
erlang:element(
5,
Config@1
)
);
{error, Err@1} ->
handle_error(
Flow,
Ctx,
Instance,
{some, Err@1}
)
end;
{error, Err@2} ->
handle_error(
Flow,
Ctx,
Instance,
{some, Err@2}
)
end;
{error, _} ->
handle_error(Flow, Ctx, Instance, none)
end
end
end
end.
-file("src/telega/flow/engine.gleam", 648).
-spec run_flow_enter_hook(
gleam@option:option(fun((telega@bot:context(AOQD, AOQE), telega@flow@types:flow_instance()) -> {ok,
{telega@bot:context(AOQD, AOQE), telega@flow@types:flow_instance()}} |
{error, AOQE})),
telega@bot:context(AOQD, AOQE),
telega@flow@types:flow_instance()
) -> {ok, {telega@bot:context(AOQD, AOQE), telega@flow@types:flow_instance()}} |
{error, AOQE}.
run_flow_enter_hook(Hook, Ctx, Instance) ->
case Hook of
{some, Enter_fn} ->
Enter_fn(Ctx, Instance);
none ->
{ok, {Ctx, Instance}}
end.
-file("src/telega/flow/engine.gleam", 24).
?DOC(false).
-spec start_or_resume(
telega@flow@types:flow(any(), AOKV, AOKW),
telega@bot:context(AOKV, AOKW),
integer(),
integer(),
gleam@dict:dict(binary(), binary())
) -> {ok, telega@bot:context(AOKV, AOKW)} | {error, AOKW}.
start_or_resume(Flow, Ctx, User_id, Chat_id, Initial_data) ->
Flow_id = <<<<<<<<(erlang:element(2, Flow))/binary, "_"/utf8>>/binary,
(erlang:integer_to_binary(Chat_id))/binary>>/binary,
"_"/utf8>>/binary,
(erlang:integer_to_binary(User_id))/binary>>,
case (erlang:element(3, erlang:element(7, Flow)))(Flow_id) of
{ok, {some, Existing_instance}} ->
case telega@flow@instance:is_expired(
Existing_instance,
erlang:element(17, Flow)
) of
true ->
_ = (erlang:element(4, erlang:element(7, Flow)))(
erlang:element(2, Existing_instance)
),
Initial_step_name = (erlang:element(5, Flow))(
erlang:element(4, Flow)
),
New_instance = telega@flow@instance:new_instance_with_data(
Flow_id,
erlang:element(2, Flow),
User_id,
Chat_id,
Initial_step_name,
Initial_data
),
case (erlang:element(2, erlang:element(7, Flow)))(
New_instance
) of
{ok, _} ->
case run_flow_enter_hook(
erlang:element(14, Flow),
Ctx,
New_instance
) of
{ok, {Ctx_after_enter, Instance_after_enter}} ->
execute_step(
Flow,
Ctx_after_enter,
Instance_after_enter
);
{error, Err} ->
handle_error(
Flow,
Ctx,
New_instance,
{some, Err}
)
end;
{error, Err@1} ->
handle_error(Flow, Ctx, New_instance, {some, Err@1})
end;
false ->
execute_step(Flow, Ctx, Existing_instance)
end;
{ok, none} ->
Initial_step_name@1 = (erlang:element(5, Flow))(
erlang:element(4, Flow)
),
New_instance@1 = telega@flow@instance:new_instance_with_data(
Flow_id,
erlang:element(2, Flow),
User_id,
Chat_id,
Initial_step_name@1,
Initial_data
),
case (erlang:element(2, erlang:element(7, Flow)))(New_instance@1) of
{ok, _} ->
case run_flow_enter_hook(
erlang:element(14, Flow),
Ctx,
New_instance@1
) of
{ok, {Ctx_after_enter@1, Instance_after_enter@1}} ->
execute_step(
Flow,
Ctx_after_enter@1,
Instance_after_enter@1
);
{error, Err@2} ->
handle_error(
Flow,
Ctx,
New_instance@1,
{some, Err@2}
)
end;
{error, Err@3} ->
handle_error(Flow, Ctx, New_instance@1, {some, Err@3})
end;
{error, Err@4} ->
Dummy_instance = telega@flow@instance:new_instance(
Flow_id,
erlang:element(2, Flow),
User_id,
Chat_id,
<<""/utf8>>
),
handle_error(Flow, Ctx, Dummy_instance, {some, Err@4})
end.
-file("src/telega/flow/engine.gleam", 115).
?DOC(false).
-spec resume_with_instance(
telega@flow@types:flow(any(), AOLY, AOLZ),
telega@bot:context(AOLY, AOLZ),
telega@flow@types:flow_instance(),
gleam@option:option(gleam@dict:dict(binary(), binary()))
) -> {ok, telega@bot:context(AOLY, AOLZ)} | {error, AOLZ}.
resume_with_instance(Flow, Ctx, Instance, Data) ->
Updated_instance = case Data of
{some, D} ->
{flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
maps:merge(erlang:element(7, Instance), D),
none,
none,
erlang:element(10, Instance),
erlang:element(11, Instance)};
none ->
{flow_instance,
erlang:element(2, Instance),
erlang:element(3, Instance),
erlang:element(4, Instance),
erlang:element(5, Instance),
erlang:element(6, Instance),
erlang:element(7, Instance),
none,
none,
erlang:element(10, Instance),
erlang:element(11, Instance)}
end,
execute_step(Flow, Ctx, Updated_instance).
-file("src/telega/flow/engine.gleam", 833).
-spec find_instance_by_token(telega@flow@types:flow_storage(AOTT), binary()) -> {ok,
gleam@option:option(telega@flow@types:flow_instance())} |
{error, AOTT}.
find_instance_by_token(Storage, Token) ->
case gleam@string:split(Token, <<":"/utf8>>) of
[Instance_id | _] ->
(erlang:element(3, Storage))(Instance_id);
_ ->
{ok, none}
end.
-file("src/telega/flow/engine.gleam", 101).
?DOC(false).
-spec resume_with_token(
telega@flow@types:flow(any(), AOLJ, AOLK),
telega@bot:context(AOLJ, AOLK),
binary(),
gleam@option:option(gleam@dict:dict(binary(), binary()))
) -> {ok, telega@bot:context(AOLJ, AOLK)} | {error, AOLK}.
resume_with_token(Flow, Ctx, Token, Data) ->
case find_instance_by_token(erlang:element(7, Flow), Token) of
{ok, {some, Instance}} ->
resume_with_instance(Flow, Ctx, Instance, Data);
_ ->
{ok, Ctx}
end.
-file("src/telega/flow/engine.gleam", 233).
?DOC(false).
-spec extract_ids_from_context(telega@bot:context(any(), any())) -> {integer(),
integer()}.
extract_ids_from_context(Ctx) ->
{erlang:element(2, erlang:element(3, Ctx)),
erlang:element(3, erlang:element(3, Ctx))}.