Stage 7

src/core/core_ticket.erl

@@ -0,0 +1,143 @@
+-module(core_ticket).
+-include("records.hrl").
+
+-export([create_or_update/3, get_by_id/1, get_by_error_hash/1, list_all/0, list_by_status/1]).
+-export([update_status/2, assign/2, add_resolution/2]).
+-export([generate_id/0, generate_error_hash/2]).
+
+%% Создать или обновить тикет (группировка по хэшу ошибки)
+create_or_update(ErrorMessage, Stacktrace, Context) ->
+  ErrorHash = generate_error_hash(ErrorMessage, Stacktrace),
+  case get_by_error_hash(ErrorHash) of
+    {error, not_found} ->
+      % Создаём новый тикет
+      Id = generate_id(),
+      Now = calendar:universal_time(),
+      Ticket = #ticket{
+        id = Id,
+        error_hash = ErrorHash,
+        error_message = ErrorMessage,
+        stacktrace = Stacktrace,
+        context = term_to_binary(Context),
+        count = 1,
+        first_seen = Now,
+        last_seen = Now,
+        status = open,
+        assigned_to = undefined,
+        resolution_note = undefined
+      },
+      F = fun() ->
+        mnesia:write(Ticket),
+        {ok, Ticket}
+          end,
+      case mnesia:transaction(F) of
+        {atomic, Result} -> Result;
+        {aborted, Reason} -> {error, Reason}
+      end;
+    {ok, Ticket} ->
+      % Обновляем существующий
+      F = fun() ->
+        Updated = Ticket#ticket{
+          count = Ticket#ticket.count + 1,
+          last_seen = calendar:universal_time()
+        },
+        mnesia:write(Updated),
+        {ok, Updated}
+          end,
+      case mnesia:transaction(F) of
+        {atomic, Result} -> Result;
+        {aborted, Reason} -> {error, Reason}
+      end
+  end.
+
+%% Получение тикета по ID
+get_by_id(Id) ->
+  case mnesia:dirty_read(ticket, Id) of
+    [] -> {error, not_found};
+    [Ticket] -> {ok, Ticket}
+  end.
+
+%% Получение тикета по хэшу ошибки
+get_by_error_hash(ErrorHash) ->
+  Match = #ticket{error_hash = ErrorHash, _ = '_'},
+  case mnesia:dirty_match_object(Match) of
+    [] -> {error, not_found};
+    [Ticket] -> {ok, Ticket}
+  end.
+
+%% Список всех тикетов
+list_all() ->
+  Match = #ticket{_ = '_'},
+  Tickets = mnesia:dirty_match_object(Match),
+  {ok, lists:sort(fun(A, B) -> A#ticket.last_seen >= B#ticket.last_seen end, Tickets)}.
+
+%% Список тикетов по статусу
+list_by_status(Status) ->
+  Match = #ticket{status = Status, _ = '_'},
+  Tickets = mnesia:dirty_match_object(Match),
+  {ok, lists:sort(fun(A, B) -> A#ticket.last_seen >= B#ticket.last_seen end, Tickets)}.
+
+%% Обновление статуса тикета
+update_status(Id, Status) when Status =:= open; Status =:= in_progress; Status =:= resolved; Status =:= closed ->
+  F = fun() ->
+    case mnesia:read(ticket, Id) of
+      [] ->
+        {error, not_found};
+      [Ticket] ->
+        Updated = Ticket#ticket{status = Status},
+        mnesia:write(Updated),
+        {ok, Updated}
+    end
+      end,
+  case mnesia:transaction(F) of
+    {atomic, Result} -> Result;
+    {aborted, Reason} -> {error, Reason}
+  end.
+
+%% Назначить тикет администратору
+assign(Id, AdminId) ->
+  F = fun() ->
+    case mnesia:read(ticket, Id) of
+      [] ->
+        {error, not_found};
+      [Ticket] ->
+        Updated = Ticket#ticket{
+          assigned_to = AdminId,
+          status = case Ticket#ticket.status of
+                     open -> in_progress;
+                     S -> S
+                   end
+        },
+        mnesia:write(Updated),
+        {ok, Updated}
+    end
+      end,
+  case mnesia:transaction(F) of
+    {atomic, Result} -> Result;
+    {aborted, Reason} -> {error, Reason}
+  end.
+
+%% Добавить примечание о решении
+add_resolution(Id, Note) ->
+  F = fun() ->
+    case mnesia:read(ticket, Id) of
+      [] ->
+        {error, not_found};
+      [Ticket] ->
+        Updated = Ticket#ticket{resolution_note = Note},
+        mnesia:write(Updated),
+        {ok, Updated}
+    end
+      end,
+  case mnesia:transaction(F) of
+    {atomic, Result} -> Result;
+    {aborted, Reason} -> {error, Reason}
+  end.
+
+%% Внутренние функции
+generate_id() ->
+  base64:encode(crypto:strong_rand_bytes(16), #{mode => urlsafe, padding => false}).
+
+generate_error_hash(ErrorMessage, Stacktrace) ->
+  Data = iolist_to_binary([ErrorMessage, "\n", Stacktrace]),
+  base64:encode(crypto:hash(sha256, Data), #{mode => urlsafe, padding => false}).

src/eventhub_app.erl

@@ -44,11 +44,19 @@ start_http() ->
       {"/v1/reviews", handler_reviews, []},
       {"/v1/reviews/:id", handler_review_by_id, []},
       {"/v1/reports", handler_reports, []},
+      {"/v1/tickets", handler_tickets, []},
+
+      % Админские маршруты - более конкретные ПЕРЕД общими
       {"/v1/admin/reports", handler_reports, []},
       {"/v1/admin/reports/:id", handler_report_by_id, []},
       {"/v1/admin/reviews/:id", handler_admin_reviews, []},
       {"/v1/admin/banned-words", handler_banned_words, []},
       {"/v1/admin/banned-words/:word", handler_banned_words, []},
+      {"/v1/admin/tickets/stats", handler_ticket_stats, []},
+      {"/v1/admin/tickets/:id", handler_ticket_by_id, []},
+      {"/v1/admin/tickets", handler_tickets, []},
+
+      % Общий маршрут для заморозки (должен быть последним)
       {"/v1/admin/:target_type/:id", handler_admin_moderation, []}
     ]}
   ]),

src/handlers/handler_ticket_by_id.erl

@@ -0,0 +1,162 @@
+-module(handler_ticket_by_id).
+-include("records.hrl").
+
+-export([init/2]).
+
+init(Req, Opts) ->
+  handle(Req, Opts).
+
+handle(Req, _Opts) ->
+  case cowboy_req:method(Req) of
+    <<"GET">> -> get_ticket(Req);
+    <<"PUT">> -> update_ticket(Req);
+    _ -> send_error(Req, 405, <<"Method not allowed">>)
+  end.
+
+%% GET /v1/admin/tickets/:id - получить тикет
+get_ticket(Req) ->
+  case handler_auth:authenticate(Req) of
+    {ok, AdminId, Req1} ->
+      TicketId = cowboy_req:binding(id, Req1),
+      case logic_ticket:get_ticket(AdminId, TicketId) of
+        {ok, Ticket} ->
+          Response = ticket_to_json(Ticket),
+          send_json(Req1, 200, Response);
+        {error, access_denied} ->
+          send_error(Req1, 403, <<"Admin access required">>);
+        {error, not_found} ->
+          send_error(Req1, 404, <<"Ticket not found">>);
+        {error, _} ->
+          send_error(Req1, 500, <<"Internal server error">>)
+      end;
+    {error, Code, Message, Req1} ->
+      send_error(Req1, Code, Message)
+  end.
+
+%% PUT /v1/admin/tickets/:id - обновить тикет
+update_ticket(Req) ->
+  case handler_auth:authenticate(Req) of
+    {ok, AdminId, Req1} ->
+      TicketId = cowboy_req:binding(id, Req1),
+      {ok, Body, Req2} = cowboy_req:read_body(Req1),
+      try jsx:decode(Body, [return_maps]) of
+        Decoded when is_map(Decoded) ->
+          handle_ticket_action(AdminId, TicketId, Decoded, Req2);
+        _ ->
+          send_error(Req2, 400, <<"Invalid JSON">>)
+      catch
+        _:_ ->
+          send_error(Req2, 400, <<"Invalid JSON format">>)
+      end;
+    {error, Code, Message, Req1} ->
+      send_error(Req1, Code, Message)
+  end.
+
+%% Обработка действий с тикетом
+handle_ticket_action(AdminId, TicketId, Body, Req) ->
+  case maps:get(<<"action">>, Body, undefined) of
+    <<"status">> ->
+      case maps:get(<<"status">>, Body, undefined) of
+        StatusBin when StatusBin =:= <<"open">>;
+          StatusBin =:= <<"in_progress">>;
+          StatusBin =:= <<"resolved">>;
+          StatusBin =:= <<"closed">> ->
+          Status = binary_to_atom(StatusBin),
+          case logic_ticket:update_status(AdminId, TicketId, Status) of
+            {ok, Ticket} ->
+              Response = ticket_to_json(Ticket),
+              send_json(Req, 200, Response);
+            {error, access_denied} ->
+              send_error(Req, 403, <<"Admin access required">>);
+            {error, not_found} ->
+              send_error(Req, 404, <<"Ticket not found">>);
+            {error, _} ->
+              send_error(Req, 500, <<"Internal server error">>)
+          end;
+        _ ->
+          send_error(Req, 400, <<"Invalid status">>)
+      end;
+    <<"assign">> ->
+      case maps:get(<<"admin_id">>, Body, undefined) of
+        undefined ->
+          send_error(Req, 400, <<"Missing admin_id field">>);
+        AssignToId ->
+          case logic_ticket:assign_ticket(AdminId, TicketId, AssignToId) of
+            {ok, Ticket} ->
+              Response = ticket_to_json(Ticket),
+              send_json(Req, 200, Response);
+            {error, access_denied} ->
+              send_error(Req, 403, <<"Admin access required">>);
+            {error, not_found} ->
+              send_error(Req, 404, <<"Ticket not found">>);
+            {error, _} ->
+              send_error(Req, 500, <<"Internal server error">>)
+          end
+      end;
+    <<"resolve">> ->
+      Note = maps:get(<<"note">>, Body, <<"">>),
+      case logic_ticket:resolve_ticket(AdminId, TicketId, Note) of
+        {ok, Ticket} ->
+          Response = ticket_to_json(Ticket),
+          send_json(Req, 200, Response);
+        {error, access_denied} ->
+          send_error(Req, 403, <<"Admin access required">>);
+        {error, not_found} ->
+          send_error(Req, 404, <<"Ticket not found">>);
+        {error, _} ->
+          send_error(Req, 500, <<"Internal server error">>)
+      end;
+    <<"close">> ->
+      case logic_ticket:close_ticket(AdminId, TicketId) of
+        {ok, Ticket} ->
+          Response = ticket_to_json(Ticket),
+          send_json(Req, 200, Response);
+        {error, access_denied} ->
+          send_error(Req, 403, <<"Admin access required">>);
+        {error, not_found} ->
+          send_error(Req, 404, <<"Ticket not found">>);
+        {error, _} ->
+          send_error(Req, 500, <<"Internal server error">>)
+      end;
+    _ ->
+      send_error(Req, 400, <<"Invalid action">>)
+  end.
+
+%% Вспомогательные функции
+ticket_to_json(Ticket) ->
+  Context = try binary_to_term(Ticket#ticket.context) of
+              C -> C
+            catch
+              _:_ -> #{}
+            end,
+
+  #{
+    id => Ticket#ticket.id,
+    error_hash => Ticket#ticket.error_hash,
+    error_message => Ticket#ticket.error_message,
+    stacktrace => Ticket#ticket.stacktrace,
+    context => Context,
+    count => Ticket#ticket.count,
+    first_seen => datetime_to_iso8601(Ticket#ticket.first_seen),
+    last_seen => datetime_to_iso8601(Ticket#ticket.last_seen),
+    status => Ticket#ticket.status,
+    assigned_to => Ticket#ticket.assigned_to,
+    resolution_note => Ticket#ticket.resolution_note
+  }.
+
+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])).
+
+binary_to_atom(<<"open">>) -> open;
+binary_to_atom(<<"in_progress">>) -> in_progress;
+binary_to_atom(<<"resolved">>) -> resolved;
+binary_to_atom(<<"closed">>) -> closed.
+
+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_ticket_stats.erl

@@ -0,0 +1,37 @@
+-module(handler_ticket_stats).
+-include("records.hrl").
+
+-export([init/2]).
+
+init(Req, Opts) ->
+  handle(Req, Opts).
+
+handle(Req, _Opts) ->
+  case cowboy_req:method(Req) of
+    <<"GET">> -> get_statistics(Req);
+    _ -> send_error(Req, 405, <<"Method not allowed">>)
+  end.
+
+%% GET /v1/admin/tickets/stats - статистика по тикетам
+get_statistics(Req) ->
+  case handler_auth:authenticate(Req) of
+    {ok, AdminId, Req1} ->
+      case logic_ticket:get_statistics(AdminId) of
+        Stats when is_map(Stats) ->
+          send_json(Req1, 200, Stats);
+        {error, access_denied} ->
+          send_error(Req1, 403, <<"Admin access required">>);
+        {error, _} ->
+          send_error(Req1, 500, <<"Internal server error">>)
+      end;
+    {error, Code, Message, Req1} ->
+      send_error(Req1, Code, Message)
+  end.
+
+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_tickets.erl

@@ -0,0 +1,118 @@
+-module(handler_tickets).
+-include("records.hrl").
+
+-export([init/2]).
+
+init(Req, Opts) ->
+  handle(Req, Opts).
+
+handle(Req, _Opts) ->
+  case cowboy_req:method(Req) of
+    <<"GET">> -> list_tickets(Req);
+    <<"POST">> -> report_error(Req);
+    _ -> send_error(Req, 405, <<"Method not allowed">>)
+  end.
+
+%% POST /v1/tickets - сообщить об ошибке (доступно всем)
+report_error(Req) ->
+  case handler_auth:authenticate(Req) of
+    {ok, UserId, Req1} ->
+      {ok, Body, Req2} = cowboy_req:read_body(Req1),
+      try jsx:decode(Body, [return_maps]) of
+        Decoded when is_map(Decoded) ->
+          case Decoded of
+            #{<<"error_message">> := ErrorMessage} ->
+              Stacktrace = maps:get(<<"stacktrace">>, Decoded, <<"">>),
+              Context = maps:get(<<"context">>, Decoded, #{}),
+
+              case logic_ticket:report_error(ErrorMessage, Stacktrace, Context) of
+                {ok, Ticket} ->
+                  Response = ticket_to_json(Ticket),
+                  send_json(Req2, 201, Response);
+                {error, _} ->
+                  send_error(Req2, 500, <<"Internal server error">>)
+              end;
+            _ ->
+              send_error(Req2, 400, <<"Missing error_message field">>)
+          end;
+        _ ->
+          send_error(Req2, 400, <<"Invalid JSON">>)
+      catch
+        _:_ ->
+          send_error(Req2, 400, <<"Invalid JSON format">>)
+      end;
+    {error, Code, Message, Req1} ->
+      send_error(Req1, Code, Message)
+  end.
+
+%% GET /v1/admin/tickets - список тикетов (только админ)
+list_tickets(Req) ->
+  case handler_auth:authenticate(Req) of
+    {ok, AdminId, Req1} ->
+      Qs = cowboy_req:parse_qs(Req1),
+      case proplists:get_value(<<"status">>, Qs) of
+        undefined ->
+          case logic_ticket:list_tickets(AdminId) of
+            {ok, Tickets} ->
+              Response = [ticket_to_json(T) || T <- Tickets],
+              send_json(Req1, 200, Response);
+            {error, access_denied} ->
+              send_error(Req1, 403, <<"Admin access required">>);
+            {error, _} ->
+              send_error(Req1, 500, <<"Internal server error">>)
+          end;
+        StatusBin ->
+          Status = parse_status(StatusBin),
+          case logic_ticket:list_tickets_by_status(AdminId, Status) of
+            {ok, Tickets} ->
+              Response = [ticket_to_json(T) || T <- Tickets],
+              send_json(Req1, 200, Response);
+            {error, access_denied} ->
+              send_error(Req1, 403, <<"Admin access required">>);
+            {error, _} ->
+              send_error(Req1, 500, <<"Internal server error">>)
+          end
+      end;
+    {error, Code, Message, Req1} ->
+      send_error(Req1, Code, Message)
+  end.
+
+%% Вспомогательные функции
+parse_status(<<"open">>) -> open;
+parse_status(<<"in_progress">>) -> in_progress;
+parse_status(<<"resolved">>) -> resolved;
+parse_status(<<"closed">>) -> closed;
+parse_status(_) -> open.
+
+ticket_to_json(Ticket) ->
+  Context = try binary_to_term(Ticket#ticket.context) of
+              C -> C
+            catch
+              _:_ -> #{}
+            end,
+
+  #{
+    id => Ticket#ticket.id,
+    error_hash => Ticket#ticket.error_hash,
+    error_message => Ticket#ticket.error_message,
+    stacktrace => Ticket#ticket.stacktrace,
+    context => Context,
+    count => Ticket#ticket.count,
+    first_seen => datetime_to_iso8601(Ticket#ticket.first_seen),
+    last_seen => datetime_to_iso8601(Ticket#ticket.last_seen),
+    status => Ticket#ticket.status,
+    assigned_to => Ticket#ticket.assigned_to,
+    resolution_note => Ticket#ticket.resolution_note
+  }.
+
+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/logic/logic_ticket.erl

@@ -0,0 +1,107 @@
+-module(logic_ticket).
+-include("records.hrl").
+
+-export([report_error/3, get_ticket/2, list_tickets/1, list_tickets_by_status/2]).
+-export([update_status/3, assign_ticket/3, resolve_ticket/3, close_ticket/2]).
+-export([get_statistics/1]).
+
+%% Зарегистрировать ошибку (создать или обновить тикет)
+report_error(ErrorMessage, Stacktrace, Context) ->
+  case core_ticket:create_or_update(ErrorMessage, Stacktrace, Context) of
+    {ok, Ticket} ->
+      % Если это новый тикет, уведомляем администраторов (заглушка)
+      case Ticket#ticket.count of
+        1 -> notify_admins(Ticket);
+        _ -> ok
+      end,
+      {ok, Ticket};
+    Error -> Error
+  end.
+
+%% Получить тикет (только для админов)
+get_ticket(AdminId, TicketId) ->
+  case is_admin(AdminId) of
+    true -> core_ticket:get_by_id(TicketId);
+    false -> {error, access_denied}
+  end.
+
+%% Список всех тикетов (только для админов)
+list_tickets(AdminId) ->
+  case is_admin(AdminId) of
+    true -> core_ticket:list_all();
+    false -> {error, access_denied}
+  end.
+
+%% Список тикетов по статусу (только для админов)
+list_tickets_by_status(AdminId, Status) ->
+  case is_admin(AdminId) of
+    true -> core_ticket:list_by_status(Status);
+    false -> {error, access_denied}
+  end.
+
+%% Обновить статус тикета
+update_status(AdminId, TicketId, Status) ->
+  case is_admin(AdminId) of
+    true -> core_ticket:update_status(TicketId, Status);
+    false -> {error, access_denied}
+  end.
+
+%% Назначить тикет администратору
+assign_ticket(AdminId, TicketId, AssignToId) ->
+  case is_admin(AdminId) of
+    true -> core_ticket:assign(TicketId, AssignToId);
+    false -> {error, access_denied}
+  end.
+
+%% Отметить тикет как решённый с примечанием
+resolve_ticket(AdminId, TicketId, ResolutionNote) ->
+  case is_admin(AdminId) of
+    true ->
+      case core_ticket:add_resolution(TicketId, ResolutionNote) of
+        {ok, Ticket} ->
+          core_ticket:update_status(TicketId, resolved);
+        Error -> Error
+      end;
+    false -> {error, access_denied}
+  end.
+
+%% Закрыть тикет
+close_ticket(AdminId, TicketId) ->
+  case is_admin(AdminId) of
+    true -> core_ticket:update_status(TicketId, closed);
+    false -> {error, access_denied}
+  end.
+
+%% Получить статистику по тикетам
+get_statistics(AdminId) ->
+  case is_admin(AdminId) of
+    true ->
+      {ok, AllTickets} = core_ticket:list_all(),
+      Open = length([T || T <- AllTickets, T#ticket.status =:= open]),
+      InProgress = length([T || T <- AllTickets, T#ticket.status =:= in_progress]),
+      Resolved = length([T || T <- AllTickets, T#ticket.status =:= resolved]),
+      Closed = length([T || T <- AllTickets, T#ticket.status =:= closed]),
+      TotalErrors = lists:sum([T#ticket.count || T <- AllTickets]),
+      #{
+        total_tickets => length(AllTickets),
+        open => Open,
+        in_progress => InProgress,
+        resolved => Resolved,
+        closed => Closed,
+        total_errors => TotalErrors
+      };
+    false -> {error, access_denied}
+  end.
+
+%% ============ Вспомогательные функции ============
+
+is_admin(UserId) ->
+  case core_user:get_by_id(UserId) of
+    {ok, User} -> User#user.role =:= admin;
+    _ -> false
+  end.
+
+notify_admins(_Ticket) ->
+  % Заглушка для уведомлений администраторов
+  % В будущем здесь будет отправка email/websocket
+  ok.