Stage 3.3

src/handlers/handler_event_occurrences.erl

@@ -0,0 +1,141 @@
+-module(handler_event_occurrences).
+-include("records.hrl").
+
+-export([init/2]).
+
+init(Req, Opts) ->
+  handle(Req, Opts).
+
+handle(Req, _Opts) ->
+  case cowboy_req:method(Req) of
+    <<"GET">> -> get_occurrences(Req);
+    <<"DELETE">> -> cancel_occurrence(Req);
+    _ -> send_error(Req, 405, <<"Method not allowed">>)
+  end.
+
+%% GET /v1/events/:id/occurrences - получение вхождений повторяющегося события
+get_occurrences(Req) ->
+  case handler_auth:authenticate(Req) of
+    {ok, UserId, Req1} ->
+      EventId = cowboy_req:binding(id, Req1),
+      Qs = cowboy_req:parse_qs(Req1),
+
+      % Параметры диапазона
+      From = proplists:get_value(<<"from">>, Qs, undefined),
+      To = proplists:get_value(<<"to">>, Qs, undefined),
+
+      case {From, To} of
+        {undefined, _} ->
+          send_error(Req1, 400, <<"Missing 'from' parameter">>);
+        {_, undefined} ->
+          send_error(Req1, 400, <<"Missing 'to' parameter">>);
+        {FromStr, ToStr} ->
+          case {parse_datetime(FromStr), parse_datetime(ToStr)} of
+            {{ok, FromDt}, {ok, ToDt}} ->
+              case logic_event:get_occurrences(UserId, EventId, ToDt) of
+                {ok, Occurrences} ->
+                  % Фильтруем по from
+                  Filtered = filter_from(Occurrences, FromDt),
+                  Response = occurrences_to_json(Filtered),
+                  send_json(Req1, 200, Response);
+                {error, not_recurring} ->
+                  send_error(Req1, 400, <<"Event is not recurring">>);
+                {error, access_denied} ->
+                  send_error(Req1, 403, <<"Access denied">>);
+                {error, not_found} ->
+                  send_error(Req1, 404, <<"Event not found">>);
+                {error, _} ->
+                  send_error(Req1, 500, <<"Internal server error">>)
+              end;
+            _ ->
+              send_error(Req1, 400, <<"Invalid date format. Use ISO 8601">>)
+          end
+      end;
+    {error, Code, Message, Req1} ->
+      send_error(Req1, Code, Message)
+  end.
+
+%% DELETE /v1/events/:id/occurrences/:start_time - отмена вхождения
+cancel_occurrence(Req) ->
+  case handler_auth:authenticate(Req) of
+    {ok, UserId, Req1} ->
+      EventId = cowboy_req:binding(id, Req1),
+      StartTimeStr = cowboy_req:binding(start_time, Req1),
+
+      case parse_datetime(StartTimeStr) of
+        {ok, StartTime} ->
+          case logic_event:cancel_occurrence(UserId, EventId, StartTime) of
+            {ok, cancelled} ->
+              send_json(Req1, 200, #{status => <<"cancelled">>});
+            {error, not_recurring} ->
+              send_error(Req1, 400, <<"Event is not recurring">>);
+            {error, access_denied} ->
+              send_error(Req1, 403, <<"Access denied">>);
+            {error, not_found} ->
+              send_error(Req1, 404, <<"Event not found">>);
+            {error, _} ->
+              send_error(Req1, 500, <<"Internal server error">>)
+          end;
+        {error, _} ->
+          send_error(Req1, 400, <<"Invalid start_time format">>)
+      end;
+    {error, Code, Message, Req1} ->
+      send_error(Req1, Code, Message)
+  end.
+
+%% Вспомогательные функции
+parse_datetime(Str) ->
+  try
+    [DateStr, TimeStr] = string:split(Str, "T"),
+    TimeStrNoZ = string:trim(TimeStr, trailing, "Z"),
+
+    [YearStr, MonthStr, DayStr] = string:split(DateStr, "-", all),
+    [HourStr, MinuteStr, SecondStr] = string:split(TimeStrNoZ, ":", all),
+
+    Year = binary_to_integer(YearStr),
+    Month = binary_to_integer(MonthStr),
+    Day = binary_to_integer(DayStr),
+    Hour = binary_to_integer(HourStr),
+    Minute = binary_to_integer(MinuteStr),
+    Second = binary_to_integer(SecondStr),
+
+    {ok, {{Year, Month, Day}, {Hour, Minute, Second}}}
+  catch
+    _:_ -> {error, invalid_format}
+  end.
+
+filter_from(Occurrences, From) ->
+  lists:filter(fun
+                 ({virtual, Occ}) -> Occ >= From;
+                 ({materialized, Event}) -> Event#event.start_time >= From
+               end, Occurrences).
+
+occurrences_to_json(Occurrences) ->
+  lists:map(fun occurrence_to_json/1, Occurrences).
+
+occurrence_to_json({virtual, Occ}) ->
+  #{
+    start_time => datetime_to_iso8601(Occ),
+    is_virtual => true
+  };
+occurrence_to_json({materialized, Event}) ->
+  #{
+    id => Event#event.id,
+    start_time => datetime_to_iso8601(Event#event.start_time),
+    duration => Event#event.duration,
+    specialist_id => Event#event.specialist_id,
+    is_virtual => false,
+    status => Event#event.status
+  }.
+
+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])).
+
+send_json(Req, Status, Data) ->
+  Body = jsx:encode(Data),
+  cowboy_req:reply(Status, #{<<"content-type">> => <<"application/json">>}, Body, Req).
+
+send_error(Req, Status, Message) ->
+  Body = jsx:encode(#{error => Message}),
+  cowboy_req:reply(Status, #{<<"content-type">> => <<"application/json">>}, Body, Req).

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])).