Stage 3.3

src/handlers/handler_events.erl

@@ -27,18 +27,40 @@ create_event(Req) ->
               <<"duration">> := Duration} ->
               case parse_datetime(StartTimeStr) of
                 {ok, StartTime} ->
-                  case logic_event:create_event(UserId, CalendarId, Title, StartTime, Duration) of
-                    {ok, Event} ->
-                      Response = event_to_json(Event),
-                      send_json(Req2, 201, Response);
-                    {error, access_denied} ->
-                      send_error(Req2, 403, <<"Access denied">>);
-                    {error, not_found} ->
-                      send_error(Req2, 404, <<"Calendar not found">>);
-                    {error, event_in_past} ->
-                      send_error(Req2, 400, <<"Event cannot be in the past">>);
-                    {error, _} ->
-                      send_error(Req2, 500, <<"Internal server error">>)
+                  % Проверяем, есть ли правило повторения
+                  case maps:get(<<"recurrence">>, Decoded, undefined) of
+                    undefined ->
+                      % Одиночное событие
+                      case logic_event:create_event(UserId, CalendarId, Title, StartTime, Duration) of
+                        {ok, Event} ->
+                          Response = event_to_json(Event),
+                          send_json(Req2, 201, Response);
+                        {error, access_denied} ->
+                          send_error(Req2, 403, <<"Access denied">>);
+                        {error, not_found} ->
+                          send_error(Req2, 404, <<"Calendar not found">>);
+                        {error, event_in_past} ->
+                          send_error(Req2, 400, <<"Event cannot be in the past">>);
+                        {error, _} ->
+                          send_error(Req2, 500, <<"Internal server error">>)
+                      end;
+                    RRule ->
+                      % Повторяющееся событие
+                      case logic_event:create_recurring_event(UserId, CalendarId, Title, StartTime, Duration, RRule) of
+                        {ok, Event} ->
+                          Response = event_to_json(Event),
+                          send_json(Req2, 201, Response);
+                        {error, invalid_rrule} ->
+                          send_error(Req2, 400, <<"Invalid recurrence rule">>);
+                        {error, access_denied} ->
+                          send_error(Req2, 403, <<"Access denied">>);
+                        {error, not_found} ->
+                          send_error(Req2, 404, <<"Calendar not found">>);
+                        {error, event_in_past} ->
+                          send_error(Req2, 400, <<"Event cannot be in the past">>);
+                        {error, _} ->
+                          send_error(Req2, 500, <<"Internal server error">>)
+                      end
                   end;
                 {error, _} ->
                   send_error(Req2, 400, <<"Invalid start_time format. Use ISO 8601">>)
@@ -61,9 +83,22 @@ list_events(Req) ->
   case handler_auth:authenticate(Req) of
     {ok, UserId, Req1} ->
       CalendarId = cowboy_req:binding(calendar_id, Req1),
+      % Проверяем параметры запроса для диапазона дат
+      Qs = cowboy_req:parse_qs(Req1),
+      From = proplists:get_value(<<"from">>, Qs, undefined),
+      To = proplists:get_value(<<"to">>, Qs, undefined),
+
       case logic_event:list_events(UserId, CalendarId) of
         {ok, Events} ->
-          Response = [event_to_json(E) || E <- Events],
+          % Если указан диапазон, разворачиваем повторяющиеся события
+          Response = case {From, To} of
+                       {undefined, undefined} ->
+                         [event_to_json(E) || E <- Events];
+                       {FromStr, ToStr} ->
+                         FromDt = parse_datetime_binary(FromStr),
+                         ToDt = parse_datetime_binary(ToStr),
+                         expand_recurring_events(UserId, Events, FromDt, ToDt)
+                     end,
           send_json(Req1, 200, Response);
         {error, access_denied} ->
           send_error(Req1, 403, <<"Access denied">>);
@@ -76,10 +111,46 @@ list_events(Req) ->
       send_error(Req1, Code, Message)
   end.
 
+%% Разворачивание повторяющихся событий в диапазоне
+expand_recurring_events(UserId, Events, From, To) ->
+  lists:flatmap(fun(Event) ->
+    case Event#event.event_type of
+      single ->
+        case is_in_range(Event#event.start_time, From, To) of
+          true -> [event_to_json(Event)];
+          false -> []
+        end;
+      recurring ->
+        case logic_event:get_occurrences(UserId, Event#event.id, To) of
+          {ok, Occurrences} ->
+            lists:filtermap(fun
+                              ({virtual, Occ}) ->
+                                case is_in_range(Occ, From, To) of
+                                  true -> {true, occurrence_to_json(Event, Occ)};
+                                  false -> false
+                                end;
+                              ({materialized, Instance}) ->
+                                case is_in_range(Instance#event.start_time, From, To) of
+                                  true -> {true, event_to_json(Instance)};
+                                  false -> false
+                                end
+                            end, Occurrences);
+          _ ->
+            []
+        end
+    end
+                end, Events).
+
+is_in_range(Time, From, To) ->
+  Time >= From andalso Time =< To.
+
+parse_datetime_binary(Str) ->
+  {ok, Dt} = parse_datetime(Str),
+  Dt.
+
 %% Вспомогательные функции
 parse_datetime(Str) ->
   try
-    % Ожидаем формат ISO 8601: "2026-04-20T10:00:00Z"
     [DateStr, TimeStr] = string:split(Str, "T"),
     TimeStrNoZ = string:trim(TimeStr, trailing, "Z"),
 
@@ -105,6 +176,11 @@ event_to_json(Event) ->
                      #{address => Addr, lat => Lat, lon => Lon}
                  end,
 
+  RecurrenceJson = case Event#event.recurrence_rule of
+                     undefined -> null;
+                     Rule -> jsx:decode(Rule, [return_maps])
+                   end,
+
   #{
     id => Event#event.id,
     calendar_id => Event#event.calendar_id,
@@ -113,6 +189,9 @@ event_to_json(Event) ->
     event_type => Event#event.event_type,
     start_time => datetime_to_iso8601(Event#event.start_time),
     duration => Event#event.duration,
+    recurrence => RecurrenceJson,
+    master_id => Event#event.master_id,
+    is_instance => Event#event.is_instance,
     specialist_id => Event#event.specialist_id,
     location => LocationJson,
     tags => Event#event.tags,
@@ -125,6 +204,15 @@ event_to_json(Event) ->
     updated_at => datetime_to_iso8601(Event#event.updated_at)
   }.
 
+occurrence_to_json(Master, Occurrence) ->
+  #{
+    master_id => Master#event.id,
+    start_time => datetime_to_iso8601(Occurrence),
+    duration => Master#event.duration,
+    title => Master#event.title,
+    is_virtual => true
+  }.
+
 datetime_to_iso8601({{Year, Month, Day}, {Hour, Minute, Second}}) ->
   iolist_to_binary(io_lib:format("~4..0B-~2..0B-~2..0BT~2..0B:~2..0B:~2..0BZ",
     [Year, Month, Day, Hour, Minute, Second])).