generated from VLADIMIR/template
up
This commit is contained in:
+101
@@ -41,6 +41,54 @@ option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_swagger) = {
|
||||
};
|
||||
|
||||
service EveningDetectiveServer {
|
||||
rpc GetTasks(GetTasksReq) returns (GetTasksRsp) {
|
||||
option (google.api.http) = { get: "/api/tasks" };
|
||||
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
|
||||
tags: "Задачи";
|
||||
summary: "Получить общую доску задач";
|
||||
description: "Доступно разработчикам и администратору.";
|
||||
};
|
||||
}
|
||||
rpc GetTaskAssignees(GetTaskAssigneesReq) returns (GetTaskAssigneesRsp) {
|
||||
option (google.api.http) = { get: "/api/tasks/assignees" };
|
||||
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
|
||||
tags: "Задачи";
|
||||
summary: "Получить разработчиков для назначения";
|
||||
description: "Доступно разработчикам и администратору.";
|
||||
};
|
||||
}
|
||||
rpc CreateTask(CreateTaskReq) returns (TaskRsp) {
|
||||
option (google.api.http) = { post: "/api/tasks" body: "*" };
|
||||
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
|
||||
tags: "Задачи";
|
||||
summary: "Создать задачу";
|
||||
description: "Доступно разработчикам и администратору.";
|
||||
};
|
||||
}
|
||||
rpc UpdateTask(UpdateTaskReq) returns (TaskRsp) {
|
||||
option (google.api.http) = { put: "/api/tasks/{ID}" body: "*" };
|
||||
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
|
||||
tags: "Задачи";
|
||||
summary: "Редактировать задачу";
|
||||
description: "Доступно разработчикам и администратору.";
|
||||
};
|
||||
}
|
||||
rpc SetTaskStatus(SetTaskStatusReq) returns (TaskRsp) {
|
||||
option (google.api.http) = { post: "/api/tasks/{ID}/status" body: "*" };
|
||||
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
|
||||
tags: "Задачи";
|
||||
summary: "Изменить статус задачи";
|
||||
description: "Доступно разработчикам и администратору.";
|
||||
};
|
||||
}
|
||||
rpc DeleteTask(DeleteTaskReq) returns (DeleteTaskRsp) {
|
||||
option (google.api.http) = { post: "/api/tasks/{ID}/delete" body: "*" };
|
||||
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
|
||||
tags: "Задачи";
|
||||
summary: "Удалить задачу";
|
||||
description: "Доступно разработчикам и администратору.";
|
||||
};
|
||||
}
|
||||
rpc GetParticipation(GetParticipationReq) returns (ParticipationRsp) {
|
||||
option (google.api.http) = { post: "/api/participation/get" body: "*" };
|
||||
option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
|
||||
@@ -2188,3 +2236,56 @@ message TicketPage {
|
||||
optional google.protobuf.Timestamp used_at = 7;
|
||||
string used_by = 8;
|
||||
}
|
||||
|
||||
// Developer tasks use new, in_progress, review and done statuses.
|
||||
message DeveloperTask {
|
||||
int32 ID = 1;
|
||||
string title = 2;
|
||||
string description = 3;
|
||||
string status = 4;
|
||||
// Omitted assignee means the task is unassigned.
|
||||
optional int32 assigneeID = 5;
|
||||
string assigneeName = 6;
|
||||
optional int32 authorID = 7;
|
||||
// Calendar deadline in YYYY-MM-DD format; empty means no deadline.
|
||||
string dueDate = 8;
|
||||
google.protobuf.Timestamp createdAt = 9;
|
||||
google.protobuf.Timestamp updatedAt = 10;
|
||||
// Required for updates and deletion to detect concurrent edits.
|
||||
int32 version = 11;
|
||||
}
|
||||
message TaskAssignee {
|
||||
int32 ID = 1;
|
||||
string name = 2;
|
||||
}
|
||||
message GetTasksReq {}
|
||||
message GetTasksRsp { repeated DeveloperTask tasks = 1; }
|
||||
message GetTaskAssigneesReq {}
|
||||
message GetTaskAssigneesRsp { repeated TaskAssignee assignees = 1; }
|
||||
message CreateTaskReq {
|
||||
string title = 1;
|
||||
string description = 2;
|
||||
string status = 3;
|
||||
optional int32 assigneeID = 4;
|
||||
string dueDate = 5;
|
||||
}
|
||||
message UpdateTaskReq {
|
||||
int32 ID = 1;
|
||||
string title = 2;
|
||||
string description = 3;
|
||||
string status = 4;
|
||||
optional int32 assigneeID = 5;
|
||||
string dueDate = 6;
|
||||
int32 version = 7;
|
||||
}
|
||||
message SetTaskStatusReq {
|
||||
int32 ID = 1;
|
||||
string status = 2;
|
||||
int32 version = 3;
|
||||
}
|
||||
message DeleteTaskReq {
|
||||
int32 ID = 1;
|
||||
int32 version = 2;
|
||||
}
|
||||
message TaskRsp { DeveloperTask task = 1; }
|
||||
message DeleteTaskRsp {}
|
||||
|
||||
Binary file not shown.
@@ -25,6 +25,7 @@ import (
|
||||
"evening_detective_server/internal/repos/refresh_tokens_repo"
|
||||
"evening_detective_server/internal/repos/scenarios_repo"
|
||||
"evening_detective_server/internal/repos/screen_sessions_repo"
|
||||
"evening_detective_server/internal/repos/tasks_repo"
|
||||
"evening_detective_server/internal/repos/team_answers_repo"
|
||||
"evening_detective_server/internal/repos/teams_repo"
|
||||
"evening_detective_server/internal/repos/tickets_repo"
|
||||
@@ -41,6 +42,7 @@ import (
|
||||
"evening_detective_server/internal/services/scenarios_service"
|
||||
"evening_detective_server/internal/services/screen_plan_service"
|
||||
"evening_detective_server/internal/services/screen_service"
|
||||
"evening_detective_server/internal/services/task_service"
|
||||
"evening_detective_server/internal/services/team_service"
|
||||
"evening_detective_server/internal/services/ticket_service"
|
||||
"evening_detective_server/internal/services/ui_service"
|
||||
@@ -108,6 +110,7 @@ func main() {
|
||||
processorJWT := processor_jwt.NewProcessor(os.Getenv("JWT_SECRET"))
|
||||
refreshTokensRepo := refresh_tokens_repo.NewRefreshTokensRepo(dbpool)
|
||||
usersService := users_service.NewUsersService(usersRepo, passwordGenerator, emailSender, processorJWT, refreshTokensRepo, os.Getenv("APP_BASE_URL"))
|
||||
taskService := task_service.NewTaskService(tasks_repo.NewTasksRepo(dbpool))
|
||||
uiService := ui_service.NewUIService()
|
||||
fileStorage, err := file_storage.NewRustFSStorage(
|
||||
context.Background(),
|
||||
@@ -226,6 +229,7 @@ func main() {
|
||||
playlistService,
|
||||
screenPlanService,
|
||||
mapService,
|
||||
taskService,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
@@ -2724,6 +2724,209 @@
|
||||
]
|
||||
}
|
||||
},
|
||||
"/api/tasks": {
|
||||
"get": {
|
||||
"summary": "Получить общую доску задач",
|
||||
"description": "Доступно разработчикам и администратору.",
|
||||
"operationId": "EveningDetectiveServer_GetTasks",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/evening_detective_serverGetTasksRsp"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/rpcStatus"
|
||||
}
|
||||
}
|
||||
},
|
||||
"tags": [
|
||||
"Задачи"
|
||||
]
|
||||
},
|
||||
"post": {
|
||||
"summary": "Создать задачу",
|
||||
"description": "Доступно разработчикам и администратору.",
|
||||
"operationId": "EveningDetectiveServer_CreateTask",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/evening_detective_serverTaskRsp"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/rpcStatus"
|
||||
}
|
||||
}
|
||||
},
|
||||
"parameters": [
|
||||
{
|
||||
"name": "body",
|
||||
"in": "body",
|
||||
"required": true,
|
||||
"schema": {
|
||||
"$ref": "#/definitions/evening_detective_serverCreateTaskReq"
|
||||
}
|
||||
}
|
||||
],
|
||||
"tags": [
|
||||
"Задачи"
|
||||
]
|
||||
}
|
||||
},
|
||||
"/api/tasks/assignees": {
|
||||
"get": {
|
||||
"summary": "Получить разработчиков для назначения",
|
||||
"description": "Доступно разработчикам и администратору.",
|
||||
"operationId": "EveningDetectiveServer_GetTaskAssignees",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/evening_detective_serverGetTaskAssigneesRsp"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/rpcStatus"
|
||||
}
|
||||
}
|
||||
},
|
||||
"tags": [
|
||||
"Задачи"
|
||||
]
|
||||
}
|
||||
},
|
||||
"/api/tasks/{ID}": {
|
||||
"put": {
|
||||
"summary": "Редактировать задачу",
|
||||
"description": "Доступно разработчикам и администратору.",
|
||||
"operationId": "EveningDetectiveServer_UpdateTask",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/evening_detective_serverTaskRsp"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/rpcStatus"
|
||||
}
|
||||
}
|
||||
},
|
||||
"parameters": [
|
||||
{
|
||||
"name": "ID",
|
||||
"in": "path",
|
||||
"required": true,
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
{
|
||||
"name": "body",
|
||||
"in": "body",
|
||||
"required": true,
|
||||
"schema": {
|
||||
"$ref": "#/definitions/EveningDetectiveServerUpdateTaskBody"
|
||||
}
|
||||
}
|
||||
],
|
||||
"tags": [
|
||||
"Задачи"
|
||||
]
|
||||
}
|
||||
},
|
||||
"/api/tasks/{ID}/delete": {
|
||||
"post": {
|
||||
"summary": "Удалить задачу",
|
||||
"description": "Доступно разработчикам и администратору.",
|
||||
"operationId": "EveningDetectiveServer_DeleteTask",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/evening_detective_serverDeleteTaskRsp"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/rpcStatus"
|
||||
}
|
||||
}
|
||||
},
|
||||
"parameters": [
|
||||
{
|
||||
"name": "ID",
|
||||
"in": "path",
|
||||
"required": true,
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
{
|
||||
"name": "body",
|
||||
"in": "body",
|
||||
"required": true,
|
||||
"schema": {
|
||||
"$ref": "#/definitions/EveningDetectiveServerDeleteTaskBody"
|
||||
}
|
||||
}
|
||||
],
|
||||
"tags": [
|
||||
"Задачи"
|
||||
]
|
||||
}
|
||||
},
|
||||
"/api/tasks/{ID}/status": {
|
||||
"post": {
|
||||
"summary": "Изменить статус задачи",
|
||||
"description": "Доступно разработчикам и администратору.",
|
||||
"operationId": "EveningDetectiveServer_SetTaskStatus",
|
||||
"responses": {
|
||||
"200": {
|
||||
"description": "A successful response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/evening_detective_serverTaskRsp"
|
||||
}
|
||||
},
|
||||
"default": {
|
||||
"description": "An unexpected error response.",
|
||||
"schema": {
|
||||
"$ref": "#/definitions/rpcStatus"
|
||||
}
|
||||
}
|
||||
},
|
||||
"parameters": [
|
||||
{
|
||||
"name": "ID",
|
||||
"in": "path",
|
||||
"required": true,
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
{
|
||||
"name": "body",
|
||||
"in": "body",
|
||||
"required": true,
|
||||
"schema": {
|
||||
"$ref": "#/definitions/EveningDetectiveServerSetTaskStatusBody"
|
||||
}
|
||||
}
|
||||
],
|
||||
"tags": [
|
||||
"Задачи"
|
||||
]
|
||||
}
|
||||
},
|
||||
"/api/teams": {
|
||||
"post": {
|
||||
"summary": "Создать команду",
|
||||
@@ -3586,6 +3789,15 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"EveningDetectiveServerDeleteTaskBody": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"version": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
}
|
||||
}
|
||||
},
|
||||
"EveningDetectiveServerDeleteUserRoleBody": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
@@ -3742,6 +3954,18 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"EveningDetectiveServerSetTaskStatusBody": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"status": {
|
||||
"type": "string"
|
||||
},
|
||||
"version": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
}
|
||||
}
|
||||
},
|
||||
"EveningDetectiveServerSetTeamAnswerScoreBody": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
@@ -3876,6 +4100,31 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"EveningDetectiveServerUpdateTaskBody": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"title": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"status": {
|
||||
"type": "string"
|
||||
},
|
||||
"assigneeID": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
"dueDate": {
|
||||
"type": "string"
|
||||
},
|
||||
"version": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
}
|
||||
}
|
||||
},
|
||||
"EveningDetectiveServerUpdateTeamBody": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
@@ -4162,6 +4411,27 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"evening_detective_serverCreateTaskReq": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"title": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"status": {
|
||||
"type": "string"
|
||||
},
|
||||
"assigneeID": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
"dueDate": {
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
},
|
||||
"evening_detective_serverDeleteAccountRsp": {
|
||||
"type": "object"
|
||||
},
|
||||
@@ -4186,12 +4456,63 @@
|
||||
"evening_detective_serverDeleteScenarioRsp": {
|
||||
"type": "object"
|
||||
},
|
||||
"evening_detective_serverDeleteTaskRsp": {
|
||||
"type": "object"
|
||||
},
|
||||
"evening_detective_serverDeleteTeamRsp": {
|
||||
"type": "object"
|
||||
},
|
||||
"evening_detective_serverDeleteUserRoleRsp": {
|
||||
"type": "object"
|
||||
},
|
||||
"evening_detective_serverDeveloperTask": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"ID": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
"title": {
|
||||
"type": "string"
|
||||
},
|
||||
"description": {
|
||||
"type": "string"
|
||||
},
|
||||
"status": {
|
||||
"type": "string"
|
||||
},
|
||||
"assigneeID": {
|
||||
"type": "integer",
|
||||
"format": "int32",
|
||||
"description": "Omitted assignee means the task is unassigned."
|
||||
},
|
||||
"assigneeName": {
|
||||
"type": "string"
|
||||
},
|
||||
"authorID": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
"dueDate": {
|
||||
"type": "string",
|
||||
"description": "Calendar deadline in YYYY-MM-DD format; empty means no deadline."
|
||||
},
|
||||
"createdAt": {
|
||||
"type": "string",
|
||||
"format": "date-time"
|
||||
},
|
||||
"updatedAt": {
|
||||
"type": "string",
|
||||
"format": "date-time"
|
||||
},
|
||||
"version": {
|
||||
"type": "integer",
|
||||
"format": "int32",
|
||||
"description": "Required for updates and deletion to detect concurrent edits."
|
||||
}
|
||||
},
|
||||
"description": "Developer tasks use new, in_progress, review and done statuses."
|
||||
},
|
||||
"evening_detective_serverDoor": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
@@ -4581,6 +4902,30 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"evening_detective_serverGetTaskAssigneesRsp": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"assignees": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"$ref": "#/definitions/evening_detective_serverTaskAssignee"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"evening_detective_serverGetTasksRsp": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"tasks": {
|
||||
"type": "array",
|
||||
"items": {
|
||||
"type": "object",
|
||||
"$ref": "#/definitions/evening_detective_serverDeveloperTask"
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
"evening_detective_serverGetTeamAnswersRsp": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
@@ -5271,6 +5616,26 @@
|
||||
"evening_detective_serverSubmitTeamAnswersRsp": {
|
||||
"type": "object"
|
||||
},
|
||||
"evening_detective_serverTaskAssignee": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"ID": {
|
||||
"type": "integer",
|
||||
"format": "int32"
|
||||
},
|
||||
"name": {
|
||||
"type": "string"
|
||||
}
|
||||
}
|
||||
},
|
||||
"evening_detective_serverTaskRsp": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"task": {
|
||||
"$ref": "#/definitions/evening_detective_serverDeveloperTask"
|
||||
}
|
||||
}
|
||||
},
|
||||
"evening_detective_serverTeam": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
|
||||
@@ -12,6 +12,7 @@ import (
|
||||
"evening_detective_server/internal/services/scenarios_service"
|
||||
"evening_detective_server/internal/services/screen_plan_service"
|
||||
"evening_detective_server/internal/services/screen_service"
|
||||
"evening_detective_server/internal/services/task_service"
|
||||
"evening_detective_server/internal/services/team_service"
|
||||
"evening_detective_server/internal/services/ticket_service"
|
||||
"evening_detective_server/internal/services/ui_service"
|
||||
@@ -24,6 +25,7 @@ type server struct {
|
||||
|
||||
usersService *users_service.UsersService
|
||||
uiService *ui_service.UIService
|
||||
taskService *task_service.TaskService
|
||||
fileService *file_service.FileService
|
||||
scenarioService *scenarios_service.ScenarioService
|
||||
gameService *game_service.GameService
|
||||
@@ -56,8 +58,10 @@ func NewServer(
|
||||
playlistService *playlist_service.Service,
|
||||
screenPlanService *screen_plan_service.ScreenPlanService,
|
||||
mapService *map_service.MapService,
|
||||
taskService *task_service.TaskService,
|
||||
) proto.EveningDetectiveServerServer {
|
||||
return &server{
|
||||
taskService: taskService,
|
||||
usersService: usersService,
|
||||
uiService: uiService,
|
||||
fileService: fileService,
|
||||
|
||||
@@ -0,0 +1,107 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
|
||||
"evening_detective_server/internal/modules/roles"
|
||||
proto "evening_detective_server/proto"
|
||||
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
func taskActor(ctx context.Context) (int, error) {
|
||||
claims, err := claimsFromContext(ctx)
|
||||
if err != nil {
|
||||
return 0, err
|
||||
}
|
||||
if !roles.HasRole(claims, roles.Developer) {
|
||||
return 0, status.Error(codes.PermissionDenied, "Нет доступа к задачам")
|
||||
}
|
||||
return claims.UserID, nil
|
||||
}
|
||||
|
||||
func (s *server) GetTasks(ctx context.Context, _ *proto.GetTasksReq) (*proto.GetTasksRsp, error) {
|
||||
if _, err := taskActor(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
tasks, err := s.taskService.List(ctx)
|
||||
if err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
result := &proto.GetTasksRsp{Tasks: make([]*proto.DeveloperTask, 0, len(tasks))}
|
||||
for _, task := range tasks {
|
||||
result.Tasks = append(result.Tasks, mapTask(task))
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (s *server) GetTaskAssignees(ctx context.Context, _ *proto.GetTaskAssigneesReq) (*proto.GetTaskAssigneesRsp, error) {
|
||||
if _, err := taskActor(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
users, err := s.taskService.ListAssignees(ctx)
|
||||
if err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
result := &proto.GetTaskAssigneesRsp{Assignees: make([]*proto.TaskAssignee, 0, len(users))}
|
||||
for _, user := range users {
|
||||
result.Assignees = append(result.Assignees, mapTaskAssignee(user))
|
||||
}
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func (s *server) CreateTask(ctx context.Context, req *proto.CreateTaskReq) (*proto.TaskRsp, error) {
|
||||
actorID, err := taskActor(ctx)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
task, err := taskInput(req.GetTitle(), req.GetDescription(), req.GetStatus(), req.AssigneeID, req.GetDueDate())
|
||||
if err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
task.AuthorID = &actorID
|
||||
result, err := s.taskService.Create(ctx, task)
|
||||
if err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
return &proto.TaskRsp{Task: mapTask(result)}, nil
|
||||
}
|
||||
|
||||
func (s *server) UpdateTask(ctx context.Context, req *proto.UpdateTaskReq) (*proto.TaskRsp, error) {
|
||||
if _, err := taskActor(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
task, err := taskInput(req.GetTitle(), req.GetDescription(), req.GetStatus(), req.AssigneeID, req.GetDueDate())
|
||||
if err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
task.ID = int(req.GetID())
|
||||
task.Version = int(req.GetVersion())
|
||||
result, err := s.taskService.Update(ctx, task)
|
||||
if err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
return &proto.TaskRsp{Task: mapTask(result)}, nil
|
||||
}
|
||||
|
||||
func (s *server) SetTaskStatus(ctx context.Context, req *proto.SetTaskStatusReq) (*proto.TaskRsp, error) {
|
||||
if _, err := taskActor(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result, err := s.taskService.SetStatus(ctx, int(req.GetID()), int(req.GetVersion()), req.GetStatus())
|
||||
if err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
return &proto.TaskRsp{Task: mapTask(result)}, nil
|
||||
}
|
||||
|
||||
func (s *server) DeleteTask(ctx context.Context, req *proto.DeleteTaskReq) (*proto.DeleteTaskRsp, error) {
|
||||
if _, err := taskActor(ctx); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if err := s.taskService.Delete(ctx, int(req.GetID()), int(req.GetVersion())); err != nil {
|
||||
return nil, taskErrorStatus(err)
|
||||
}
|
||||
return &proto.DeleteTaskRsp{}, nil
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"log"
|
||||
|
||||
"evening_detective_server/internal/services/task_service"
|
||||
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
func taskErrorStatus(err error) error {
|
||||
switch {
|
||||
case errors.Is(err, task_service.ErrInvalidTask):
|
||||
return status.Error(codes.InvalidArgument, task_service.ErrInvalidTask.Error())
|
||||
case errors.Is(err, task_service.ErrInvalidAssignee):
|
||||
return status.Error(codes.InvalidArgument, task_service.ErrInvalidAssignee.Error())
|
||||
case errors.Is(err, task_service.ErrNotFound):
|
||||
return status.Error(codes.NotFound, task_service.ErrNotFound.Error())
|
||||
case errors.Is(err, task_service.ErrConflict):
|
||||
return status.Error(codes.Aborted, task_service.ErrConflict.Error())
|
||||
default:
|
||||
log.Printf("task operation failed: %v", err)
|
||||
return status.Error(codes.Internal, "Не удалось выполнить операцию с задачей")
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"evening_detective_server/internal/services/task_service"
|
||||
proto "evening_detective_server/proto"
|
||||
|
||||
"google.golang.org/protobuf/types/known/timestamppb"
|
||||
)
|
||||
|
||||
func taskInput(title, description, status string, assigneeID *int32, dueDate string) (task_service.Task, error) {
|
||||
date, err := task_service.ParseDueDate(dueDate)
|
||||
if err != nil {
|
||||
return task_service.Task{}, err
|
||||
}
|
||||
return task_service.Task{
|
||||
Title: title,
|
||||
Description: description,
|
||||
Status: status,
|
||||
AssigneeID: taskDomainID(assigneeID),
|
||||
DueDate: date,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func taskDomainID(value *int32) *int {
|
||||
if value == nil {
|
||||
return nil
|
||||
}
|
||||
result := int(*value)
|
||||
return &result
|
||||
}
|
||||
|
||||
func taskProtoID(value *int) *int32 {
|
||||
if value == nil {
|
||||
return nil
|
||||
}
|
||||
result := int32(*value)
|
||||
return &result
|
||||
}
|
||||
|
||||
func mapTask(task *task_service.Task) *proto.DeveloperTask {
|
||||
dueDate := ""
|
||||
if task.DueDate != nil {
|
||||
dueDate = task.DueDate.Format("2006-01-02")
|
||||
}
|
||||
return &proto.DeveloperTask{
|
||||
ID: int32(task.ID),
|
||||
Title: task.Title,
|
||||
Description: task.Description,
|
||||
Status: task.Status,
|
||||
AssigneeID: taskProtoID(task.AssigneeID),
|
||||
AssigneeName: task.AssigneeName,
|
||||
AuthorID: taskProtoID(task.AuthorID),
|
||||
DueDate: dueDate,
|
||||
CreatedAt: timestamppb.New(task.CreatedAt),
|
||||
UpdatedAt: timestamppb.New(task.UpdatedAt),
|
||||
Version: int32(task.Version),
|
||||
}
|
||||
}
|
||||
|
||||
func mapTaskAssignee(user task_service.Assignee) *proto.TaskAssignee {
|
||||
return &proto.TaskAssignee{
|
||||
ID: int32(user.ID),
|
||||
Name: user.Name,
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
package app
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"evening_detective_server/internal/modules/processor_jwt"
|
||||
"evening_detective_server/internal/services/task_service"
|
||||
proto "evening_detective_server/proto"
|
||||
|
||||
"google.golang.org/grpc/codes"
|
||||
"google.golang.org/grpc/status"
|
||||
)
|
||||
|
||||
func TestTaskEndpointsRejectUnauthorizedRoles(t *testing.T) {
|
||||
s := &server{}
|
||||
operations := []struct {
|
||||
name string
|
||||
call func(context.Context) error
|
||||
}{
|
||||
{"list", func(ctx context.Context) error { _, err := s.GetTasks(ctx, &proto.GetTasksReq{}); return err }},
|
||||
{"assignees", func(ctx context.Context) error {
|
||||
_, err := s.GetTaskAssignees(ctx, &proto.GetTaskAssigneesReq{})
|
||||
return err
|
||||
}},
|
||||
{"create", func(ctx context.Context) error { _, err := s.CreateTask(ctx, &proto.CreateTaskReq{}); return err }},
|
||||
{"update", func(ctx context.Context) error { _, err := s.UpdateTask(ctx, &proto.UpdateTaskReq{}); return err }},
|
||||
{"status", func(ctx context.Context) error { _, err := s.SetTaskStatus(ctx, &proto.SetTaskStatusReq{}); return err }},
|
||||
{"delete", func(ctx context.Context) error { _, err := s.DeleteTask(ctx, &proto.DeleteTaskReq{}); return err }},
|
||||
}
|
||||
for _, operation := range operations {
|
||||
for _, role := range []string{"", "user", "author", "organizer"} {
|
||||
t.Run(operation.name+"/"+role, func(t *testing.T) {
|
||||
ctx := context.Background()
|
||||
want := codes.Unauthenticated
|
||||
if role != "" {
|
||||
ctx = processor_jwt.ContextWithClaims(ctx, &processor_jwt.JWTClaims{UserID: 1, Roles: []string{role}})
|
||||
want = codes.PermissionDenied
|
||||
}
|
||||
if err := operation.call(ctx); status.Code(err) != want {
|
||||
t.Fatalf("error=%v want=%v", err, want)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskActorAllowsDeveloperAndAdmin(t *testing.T) {
|
||||
for _, role := range []string{"developer", "admin"} {
|
||||
t.Run(role, func(t *testing.T) {
|
||||
ctx := processor_jwt.ContextWithClaims(context.Background(), &processor_jwt.JWTClaims{UserID: 42, Roles: []string{role}})
|
||||
id, err := taskActor(ctx)
|
||||
if id != 42 || err != nil {
|
||||
t.Fatalf("id=%d error=%v", id, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskErrorsUseSafeTransportCodes(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
err error
|
||||
code codes.Code
|
||||
}{
|
||||
{task_service.ErrInvalidTask, codes.InvalidArgument},
|
||||
{task_service.ErrInvalidAssignee, codes.InvalidArgument},
|
||||
{task_service.ErrNotFound, codes.NotFound},
|
||||
{task_service.ErrConflict, codes.Aborted},
|
||||
{errors.New("database-password-secret"), codes.Internal},
|
||||
} {
|
||||
t.Run(tc.err.Error(), func(t *testing.T) {
|
||||
err := taskErrorStatus(fmt.Errorf("database-password-secret: %w", tc.err))
|
||||
if status.Code(err) != tc.code || strings.Contains(err.Error(), "database-password-secret") {
|
||||
t.Fatalf("unsafe or incorrect error=%v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestTaskMappingPreservesOptionalFields(t *testing.T) {
|
||||
id := 4
|
||||
date := time.Date(2026, 10, 7, 0, 0, 0, 0, time.UTC)
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
assignee *int
|
||||
date *time.Time
|
||||
wantDate string
|
||||
}{
|
||||
{"unset", nil, nil, ""}, {"set", &id, &date, "2026-10-07"},
|
||||
} {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
task := mapTask(&task_service.Task{ID: 1, AssigneeID: tc.assignee, DueDate: tc.date, CreatedAt: date, UpdatedAt: date, Version: 2})
|
||||
if task.DueDate != tc.wantDate || (task.AssigneeID == nil) != (tc.assignee == nil) || task.Version != 2 {
|
||||
t.Fatalf("task=%+v", task)
|
||||
}
|
||||
input, err := taskInput("Task", "", "new", task.AssigneeID, task.DueDate)
|
||||
if err != nil || (input.AssigneeID == nil) != (tc.assignee == nil) {
|
||||
t.Fatalf("input=%+v error=%v", input, err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -3,6 +3,7 @@ package roles
|
||||
|
||||
const (
|
||||
Admin = "admin"
|
||||
Developer = "developer"
|
||||
Author = "author"
|
||||
Organizer = "organizer"
|
||||
User = "user"
|
||||
@@ -10,6 +11,7 @@ const (
|
||||
|
||||
var AllRoles = []string{
|
||||
Admin,
|
||||
Developer,
|
||||
Author,
|
||||
Organizer,
|
||||
User,
|
||||
|
||||
@@ -0,0 +1,256 @@
|
||||
// Package tasks_repo persists developer tasks.
|
||||
package tasks_repo
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"time"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgconn"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrInvalidTask = errors.New("некорректные поля задачи")
|
||||
ErrNotFound = errors.New("задача не найдена")
|
||||
ErrConflict = errors.New("задача изменена другим пользователем; обновите данные")
|
||||
ErrInvalidAssignee = errors.New("ответственный должен иметь роль разработчика")
|
||||
)
|
||||
|
||||
// Task is a persisted developer task.
|
||||
type Task struct {
|
||||
ID int
|
||||
Title string
|
||||
Description string
|
||||
Status string
|
||||
AssigneeID *int
|
||||
AssigneeName string
|
||||
AuthorID *int
|
||||
DueDate *time.Time
|
||||
CreatedAt time.Time
|
||||
UpdatedAt time.Time
|
||||
Version int
|
||||
}
|
||||
|
||||
// Assignee contains only the public identity needed for task assignment.
|
||||
type Assignee struct {
|
||||
ID int
|
||||
Name string
|
||||
}
|
||||
|
||||
// TasksRepo persists the shared task board.
|
||||
type TasksRepo struct{ pool *pgxpool.Pool }
|
||||
|
||||
func NewTasksRepo(pool *pgxpool.Pool) *TasksRepo { return &TasksRepo{pool: pool} }
|
||||
|
||||
const taskColumns = `
|
||||
id,
|
||||
title,
|
||||
description,
|
||||
status,
|
||||
assignee_id,
|
||||
author_id,
|
||||
due_date,
|
||||
created_at,
|
||||
updated_at,
|
||||
version,
|
||||
COALESCE((
|
||||
SELECT username
|
||||
FROM users
|
||||
WHERE users.id = developer_tasks.assignee_id
|
||||
), '')`
|
||||
|
||||
func scanTask(row pgx.Row) (*Task, error) {
|
||||
var task Task
|
||||
err := row.Scan(&task.ID, &task.Title, &task.Description, &task.Status,
|
||||
&task.AssigneeID, &task.AuthorID, &task.DueDate, &task.CreatedAt, &task.UpdatedAt, &task.Version, &task.AssigneeName)
|
||||
if errors.Is(err, pgx.ErrNoRows) {
|
||||
return nil, ErrNotFound
|
||||
}
|
||||
return &task, err
|
||||
}
|
||||
|
||||
func (r *TasksRepo) Get(ctx context.Context, id int) (*Task, error) {
|
||||
return scanTask(r.pool.QueryRow(
|
||||
ctx,
|
||||
`SELECT `+taskColumns+`
|
||||
FROM developer_tasks
|
||||
WHERE id = $1`,
|
||||
id,
|
||||
))
|
||||
}
|
||||
|
||||
func (r *TasksRepo) List(ctx context.Context) ([]*Task, error) {
|
||||
rows, err := r.pool.Query(
|
||||
ctx,
|
||||
`SELECT
|
||||
t.id,
|
||||
t.title,
|
||||
t.description,
|
||||
t.status,
|
||||
t.assignee_id,
|
||||
t.author_id,
|
||||
t.due_date,
|
||||
t.created_at,
|
||||
t.updated_at,
|
||||
t.version,
|
||||
COALESCE(u.username, '')
|
||||
FROM developer_tasks t
|
||||
LEFT JOIN users u ON u.id = t.assignee_id
|
||||
ORDER BY t.created_at DESC, t.id DESC`,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
tasks := make([]*Task, 0)
|
||||
for rows.Next() {
|
||||
var task Task
|
||||
if err := rows.Scan(&task.ID, &task.Title, &task.Description, &task.Status,
|
||||
&task.AssigneeID, &task.AuthorID, &task.DueDate, &task.CreatedAt,
|
||||
&task.UpdatedAt, &task.Version, &task.AssigneeName); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
tasks = append(tasks, &task)
|
||||
}
|
||||
return tasks, rows.Err()
|
||||
}
|
||||
|
||||
func (r *TasksRepo) ListAssignees(ctx context.Context) ([]Assignee, error) {
|
||||
rows, err := r.pool.Query(
|
||||
ctx,
|
||||
`SELECT
|
||||
id,
|
||||
username
|
||||
FROM users
|
||||
WHERE roles @> '["developer"]'::jsonb
|
||||
ORDER BY username, id`,
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
defer rows.Close()
|
||||
result := make([]Assignee, 0)
|
||||
for rows.Next() {
|
||||
var user Assignee
|
||||
if err := rows.Scan(&user.ID, &user.Name); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
result = append(result, user)
|
||||
}
|
||||
return result, rows.Err()
|
||||
}
|
||||
|
||||
func (r *TasksRepo) Create(ctx context.Context, task Task) (*Task, error) {
|
||||
result, err := scanTask(r.pool.QueryRow(
|
||||
ctx,
|
||||
`INSERT INTO developer_tasks (title, description, status, assignee_id, author_id, due_date)
|
||||
SELECT $1, $2, $3, $4::integer, $5::integer, $6::date
|
||||
WHERE $4::integer IS NULL OR EXISTS (
|
||||
SELECT 1
|
||||
FROM users
|
||||
WHERE id = $4 AND roles @> '["developer"]'::jsonb
|
||||
)
|
||||
RETURNING `+taskColumns,
|
||||
task.Title,
|
||||
task.Description,
|
||||
task.Status,
|
||||
task.AssigneeID,
|
||||
task.AuthorID,
|
||||
task.DueDate,
|
||||
))
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
return nil, ErrInvalidAssignee
|
||||
}
|
||||
return result, writeError(err)
|
||||
}
|
||||
|
||||
func (r *TasksRepo) Update(ctx context.Context, task Task) (*Task, error) {
|
||||
result, err := scanTask(r.pool.QueryRow(
|
||||
ctx,
|
||||
`UPDATE developer_tasks
|
||||
SET title = $1, description = $2, status = $3,
|
||||
assignee_id = $4, due_date = $5, updated_at = NOW(), version = version + 1
|
||||
WHERE id = $6 AND version = $7 AND (
|
||||
$4::integer IS NULL OR assignee_id = $4 OR EXISTS (
|
||||
SELECT 1
|
||||
FROM users
|
||||
WHERE id = $4 AND roles @> '["developer"]'::jsonb
|
||||
)
|
||||
)
|
||||
RETURNING `+taskColumns,
|
||||
task.Title,
|
||||
task.Description,
|
||||
task.Status,
|
||||
task.AssigneeID,
|
||||
task.DueDate,
|
||||
task.ID,
|
||||
task.Version,
|
||||
))
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
current, getErr := r.Get(ctx, task.ID)
|
||||
if getErr != nil {
|
||||
return nil, getErr
|
||||
}
|
||||
if current.Version != task.Version {
|
||||
return nil, ErrConflict
|
||||
}
|
||||
return nil, ErrInvalidAssignee
|
||||
}
|
||||
return result, writeError(err)
|
||||
}
|
||||
|
||||
func (r *TasksRepo) SetStatus(ctx context.Context, id, version int, status string) (*Task, error) {
|
||||
result, err := scanTask(r.pool.QueryRow(
|
||||
ctx,
|
||||
`UPDATE developer_tasks
|
||||
SET status = $1, updated_at = NOW(), version = version + 1
|
||||
WHERE id = $2 AND version = $3
|
||||
RETURNING `+taskColumns,
|
||||
status,
|
||||
id,
|
||||
version,
|
||||
))
|
||||
if errors.Is(err, ErrNotFound) {
|
||||
return nil, r.missingWrite(ctx, id)
|
||||
}
|
||||
return result, err
|
||||
}
|
||||
|
||||
func (r *TasksRepo) Delete(ctx context.Context, id, version int) error {
|
||||
tag, err := r.pool.Exec(
|
||||
ctx,
|
||||
`DELETE FROM developer_tasks
|
||||
WHERE id = $1 AND version = $2`,
|
||||
id,
|
||||
version,
|
||||
)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if tag.RowsAffected() == 0 {
|
||||
return r.missingWrite(ctx, id)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (r *TasksRepo) missingWrite(ctx context.Context, id int) error {
|
||||
if _, err := r.Get(ctx, id); err != nil {
|
||||
return err
|
||||
}
|
||||
return ErrConflict
|
||||
}
|
||||
|
||||
func writeError(err error) error {
|
||||
var pgErr *pgconn.PgError
|
||||
if errors.As(err, &pgErr) {
|
||||
switch pgErr.Code {
|
||||
case "23503":
|
||||
return ErrInvalidAssignee
|
||||
case "23514", "22001":
|
||||
return ErrInvalidTask
|
||||
}
|
||||
}
|
||||
return err
|
||||
}
|
||||
@@ -0,0 +1,279 @@
|
||||
package tasks_repo_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"evening_detective_server/internal/repos/tasks_repo"
|
||||
"evening_detective_server/internal/repos/user_agreements_repo"
|
||||
"evening_detective_server/internal/repos/users_repo"
|
||||
|
||||
"github.com/jackc/pgx/v5"
|
||||
"github.com/jackc/pgx/v5/pgxpool"
|
||||
)
|
||||
|
||||
type taskFixture struct {
|
||||
repo *tasks_repo.TasksRepo
|
||||
users *users_repo.UsersRepo
|
||||
developerID int
|
||||
otherID int
|
||||
pool *pgxpool.Pool
|
||||
}
|
||||
|
||||
// newTaskFixture prepares an isolated schema using the application's migrations.
|
||||
// Scenarios below create and inspect data only through public repository methods.
|
||||
func newTaskFixture(t *testing.T) taskFixture {
|
||||
t.Helper()
|
||||
dsn := os.Getenv("TEST_DATABASE_URL")
|
||||
if dsn == "" {
|
||||
t.Skip("set TEST_DATABASE_URL to run PostgreSQL integration checks")
|
||||
}
|
||||
ctx := context.Background()
|
||||
admin, err := pgxpool.New(ctx, dsn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
schema := fmt.Sprintf("tasks_test_%d", time.Now().UnixNano())
|
||||
quoted := pgx.Identifier{schema}.Sanitize()
|
||||
if _, err := admin.Exec(ctx, "CREATE SCHEMA "+quoted); err != nil {
|
||||
admin.Close()
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(func() {
|
||||
if _, err := admin.Exec(ctx, "DROP SCHEMA "+quoted+" CASCADE"); err != nil {
|
||||
t.Error(err)
|
||||
}
|
||||
admin.Close()
|
||||
})
|
||||
config, err := pgxpool.ParseConfig(dsn)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
config.ConnConfig.RuntimeParams["search_path"] = schema
|
||||
pool, err := pgxpool.NewWithConfig(ctx, config)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
t.Cleanup(pool.Close)
|
||||
for _, migration := range []string{
|
||||
"20260628175120_create_users_table.sql",
|
||||
"20260704192907_refresh_tokens_table.sql",
|
||||
"20260818231943_create_user_agreements_table.sql",
|
||||
"20261007130000_create_developer_tasks.sql",
|
||||
} {
|
||||
applyTaskMigration(t, pool, migration, false)
|
||||
}
|
||||
users := users_repo.NewUserRepo(pool)
|
||||
agreements := []user_agreements_repo.Agreement{{AgreementType: "terms", Version: "test"}}
|
||||
developerID, err := users.AddUserWithAgreements(ctx, "developer", "dev@test.invalid", "test-hash", []string{"user"}, agreements)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := users.AddUserRole(ctx, developerID, "developer"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
otherID, err := users.AddUserWithAgreements(ctx, "other", "other@test.invalid", "test-hash", []string{"user"}, agreements)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return taskFixture{repo: tasks_repo.NewTasksRepo(pool), users: users, developerID: developerID, otherID: otherID, pool: pool}
|
||||
}
|
||||
|
||||
// applyTaskMigration is schema infrastructure, not a task data access path.
|
||||
func applyTaskMigration(t *testing.T, pool *pgxpool.Pool, name string, down bool) {
|
||||
t.Helper()
|
||||
data, err := os.ReadFile("../../../migrations/" + name)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
parts := strings.Split(string(data), "-- +goose Down")
|
||||
sql := parts[0]
|
||||
if down {
|
||||
sql = parts[1]
|
||||
}
|
||||
if _, err := pool.Exec(context.Background(), sql); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func (f taskFixture) create(t *testing.T) *tasks_repo.Task {
|
||||
t.Helper()
|
||||
date := time.Date(2026, 10, 7, 0, 0, 0, 0, time.UTC)
|
||||
task, err := f.repo.Create(context.Background(), tasks_repo.Task{
|
||||
Title: "Task",
|
||||
Description: "Original",
|
||||
Status: "new",
|
||||
AssigneeID: &f.developerID,
|
||||
AuthorID: &f.developerID,
|
||||
DueDate: &date,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return task
|
||||
}
|
||||
|
||||
func TestTaskPersistencePostgres(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
run func(*testing.T, taskFixture)
|
||||
}{
|
||||
{"fields and clearing", func(t *testing.T, f taskFixture) {
|
||||
task := f.create(t)
|
||||
if task.Version != 1 || task.AssigneeName != "developer" || task.DueDate.Format("2006-01-02") != "2026-10-07" {
|
||||
t.Fatalf("created task=%+v", task)
|
||||
}
|
||||
task.Title, task.Description, task.Status = "Updated", "", "done"
|
||||
task.AssigneeID, task.DueDate = nil, nil
|
||||
updated, err := f.repo.Update(context.Background(), *task)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if updated.Version != 2 || updated.AssigneeID != nil || updated.DueDate != nil || updated.AssigneeName != "" || updated.AuthorID == nil {
|
||||
t.Fatalf("updated task=%+v", updated)
|
||||
}
|
||||
list, err := f.repo.List(context.Background())
|
||||
if err != nil || len(list) != 1 || list[0].Title != "Updated" {
|
||||
t.Fatalf("list=%v error=%v", list, err)
|
||||
}
|
||||
}},
|
||||
{"assignment requires developer", func(t *testing.T, f taskFixture) {
|
||||
candidates, err := f.repo.ListAssignees(context.Background())
|
||||
if err != nil || len(candidates) != 1 || candidates[0].ID != f.developerID {
|
||||
t.Fatalf("assignees=%v error=%v", candidates, err)
|
||||
}
|
||||
_, err = f.repo.Create(context.Background(), tasks_repo.Task{Title: "Invalid", Status: "new", AssigneeID: &f.otherID})
|
||||
if !errors.Is(err, tasks_repo.ErrInvalidAssignee) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
task := f.create(t)
|
||||
task.AssigneeID = &f.otherID
|
||||
_, err = f.repo.Update(context.Background(), *task)
|
||||
if !errors.Is(err, tasks_repo.ErrInvalidAssignee) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
}},
|
||||
{"revoked role preserves current assignment", func(t *testing.T, f taskFixture) {
|
||||
task := f.create(t)
|
||||
if err := f.users.DeleteUserRole(context.Background(), f.developerID, "developer"); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
task.Title = "Retained assignment"
|
||||
updated, err := f.repo.Update(context.Background(), *task)
|
||||
if err != nil || updated.AssigneeID == nil || *updated.AssigneeID != f.developerID {
|
||||
t.Fatalf("updated=%v error=%v", updated, err)
|
||||
}
|
||||
candidates, err := f.repo.ListAssignees(context.Background())
|
||||
if err != nil || len(candidates) != 0 {
|
||||
t.Fatalf("assignees=%v error=%v", candidates, err)
|
||||
}
|
||||
_, err = f.repo.Create(context.Background(), tasks_repo.Task{Title: "New assignment", Status: "new", AssigneeID: &f.developerID})
|
||||
if !errors.Is(err, tasks_repo.ErrInvalidAssignee) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
}},
|
||||
{"status writes protect other fields", func(t *testing.T, f taskFixture) {
|
||||
task := f.create(t)
|
||||
for _, state := range []string{"in_progress", "review", "done", "new"} {
|
||||
updated, err := f.repo.SetStatus(context.Background(), task.ID, task.Version, state)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if updated.Status != state || updated.Title != task.Title || updated.Description != task.Description ||
|
||||
updated.Version != task.Version+1 || updated.AssigneeID == nil || updated.DueDate == nil {
|
||||
t.Fatalf("updated=%+v", updated)
|
||||
}
|
||||
task = updated
|
||||
}
|
||||
}},
|
||||
{"concurrent writes and stale deletion", func(t *testing.T, f taskFixture) {
|
||||
task := f.create(t)
|
||||
results := make(chan error, 4)
|
||||
for range 4 {
|
||||
go func() {
|
||||
_, err := f.repo.SetStatus(context.Background(), task.ID, task.Version, "review")
|
||||
results <- err
|
||||
}()
|
||||
}
|
||||
successes := 0
|
||||
for range 4 {
|
||||
err := <-results
|
||||
if err == nil {
|
||||
successes++
|
||||
} else if !errors.Is(err, tasks_repo.ErrConflict) {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
if successes != 1 {
|
||||
t.Fatalf("successes=%d", successes)
|
||||
}
|
||||
if err := f.repo.Delete(context.Background(), task.ID, task.Version); !errors.Is(err, tasks_repo.ErrConflict) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
_, err := f.repo.Update(context.Background(), *task)
|
||||
if !errors.Is(err, tasks_repo.ErrConflict) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
current, err := f.repo.Get(context.Background(), task.ID)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := f.repo.Delete(context.Background(), current.ID, current.Version); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := f.repo.Get(context.Background(), task.ID); !errors.Is(err, tasks_repo.ErrNotFound) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
if err := f.repo.Delete(context.Background(), task.ID, current.Version); !errors.Is(err, tasks_repo.ErrNotFound) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
if _, err := f.repo.Update(context.Background(), *task); !errors.Is(err, tasks_repo.ErrNotFound) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
if _, err := f.repo.SetStatus(context.Background(), task.ID, current.Version, "new"); !errors.Is(err, tasks_repo.ErrNotFound) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
}},
|
||||
{"user deletion retains tasks", func(t *testing.T, f taskFixture) {
|
||||
task := f.create(t)
|
||||
if err := f.users.DeleteUser(context.Background(), f.developerID); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
current, err := f.repo.Get(context.Background(), task.ID)
|
||||
if err != nil || current.AssigneeID != nil || current.AuthorID != nil || current.Title != task.Title {
|
||||
t.Fatalf("task=%v error=%v", current, err)
|
||||
}
|
||||
}},
|
||||
{"database constraints", func(t *testing.T, f taskFixture) {
|
||||
for _, task := range []tasks_repo.Task{
|
||||
{Title: " ", Status: "new"}, {Title: strings.Repeat("Я", 256), Status: "new"},
|
||||
{Title: "Task", Status: "invalid"}, {Title: "Task", Status: "new", Description: strings.Repeat("Я", 10001)},
|
||||
} {
|
||||
if _, err := f.repo.Create(context.Background(), task); !errors.Is(err, tasks_repo.ErrInvalidTask) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
}
|
||||
}},
|
||||
{"migration rollback and reapply", func(t *testing.T, f taskFixture) {
|
||||
f.create(t)
|
||||
const migration = "20261007130000_create_developer_tasks.sql"
|
||||
applyTaskMigration(t, f.pool, migration, true)
|
||||
if _, err := f.repo.List(context.Background()); err == nil {
|
||||
t.Fatal("table still exists after Down")
|
||||
}
|
||||
applyTaskMigration(t, f.pool, migration, false)
|
||||
tasks, err := f.repo.List(context.Background())
|
||||
if err != nil || len(tasks) != 0 {
|
||||
t.Fatalf("tasks=%v error=%v", tasks, err)
|
||||
}
|
||||
}},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) { tc.run(t, newTaskFixture(t)) })
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
// Package task_service implements the shared developer board.
|
||||
package task_service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode/utf8"
|
||||
|
||||
"evening_detective_server/internal/repos/tasks_repo"
|
||||
)
|
||||
|
||||
var (
|
||||
ErrInvalidTask = tasks_repo.ErrInvalidTask
|
||||
ErrNotFound = tasks_repo.ErrNotFound
|
||||
ErrConflict = tasks_repo.ErrConflict
|
||||
ErrInvalidAssignee = tasks_repo.ErrInvalidAssignee
|
||||
)
|
||||
|
||||
type Task = tasks_repo.Task
|
||||
type Assignee = tasks_repo.Assignee
|
||||
|
||||
type ITasksRepo interface {
|
||||
List(context.Context) ([]*Task, error)
|
||||
ListAssignees(context.Context) ([]Assignee, error)
|
||||
Create(context.Context, Task) (*Task, error)
|
||||
Update(context.Context, Task) (*Task, error)
|
||||
SetStatus(context.Context, int, int, string) (*Task, error)
|
||||
Delete(context.Context, int, int) error
|
||||
}
|
||||
|
||||
type TaskService struct{ repo ITasksRepo }
|
||||
|
||||
func NewTaskService(repo ITasksRepo) *TaskService { return &TaskService{repo: repo} }
|
||||
|
||||
func (s *TaskService) List(ctx context.Context) ([]*Task, error) { return s.repo.List(ctx) }
|
||||
func (s *TaskService) ListAssignees(ctx context.Context) ([]Assignee, error) {
|
||||
return s.repo.ListAssignees(ctx)
|
||||
}
|
||||
|
||||
// ParseDueDate preserves calendar dates without a local time zone conversion.
|
||||
func ParseDueDate(value string) (*time.Time, error) {
|
||||
if value == "" {
|
||||
return nil, nil
|
||||
}
|
||||
date, err := time.Parse("2006-01-02", value)
|
||||
if err != nil || date.Year() < 1 {
|
||||
return nil, ErrInvalidTask
|
||||
}
|
||||
return &date, nil
|
||||
}
|
||||
|
||||
func validStatus(status string) bool {
|
||||
return status == "new" || status == "in_progress" || status == "review" || status == "done"
|
||||
}
|
||||
|
||||
func validate(task *Task) error {
|
||||
task.Title = strings.TrimSpace(task.Title)
|
||||
if task.Title == "" || strings.ContainsRune(task.Title, 0) || strings.ContainsRune(task.Description, 0) ||
|
||||
utf8.RuneCountInString(task.Title) > 255 ||
|
||||
utf8.RuneCountInString(task.Description) > 10000 || !validStatus(task.Status) ||
|
||||
(task.AssigneeID != nil && *task.AssigneeID <= 0) {
|
||||
return ErrInvalidTask
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *TaskService) Create(ctx context.Context, task Task) (*Task, error) {
|
||||
if task.Status == "" {
|
||||
task.Status = "new"
|
||||
}
|
||||
if err := validate(&task); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.repo.Create(ctx, task)
|
||||
}
|
||||
|
||||
func (s *TaskService) Update(ctx context.Context, task Task) (*Task, error) {
|
||||
if task.ID <= 0 || task.Version <= 0 {
|
||||
return nil, ErrInvalidTask
|
||||
}
|
||||
if err := validate(&task); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return s.repo.Update(ctx, task)
|
||||
}
|
||||
|
||||
func (s *TaskService) SetStatus(ctx context.Context, id, version int, status string) (*Task, error) {
|
||||
if id <= 0 || version <= 0 || !validStatus(status) {
|
||||
return nil, ErrInvalidTask
|
||||
}
|
||||
return s.repo.SetStatus(ctx, id, version, status)
|
||||
}
|
||||
|
||||
func (s *TaskService) Delete(ctx context.Context, id, version int) error {
|
||||
if id <= 0 || version <= 0 {
|
||||
return ErrInvalidTask
|
||||
}
|
||||
return s.repo.Delete(ctx, id, version)
|
||||
}
|
||||
@@ -0,0 +1,133 @@
|
||||
package task_service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
type fakeTasks struct {
|
||||
task Task
|
||||
err error
|
||||
calls int
|
||||
}
|
||||
|
||||
func (f *fakeTasks) List(context.Context) ([]*Task, error) { return []*Task{&f.task}, f.err }
|
||||
func (f *fakeTasks) ListAssignees(context.Context) ([]Assignee, error) { return nil, f.err }
|
||||
func (f *fakeTasks) Create(_ context.Context, task Task) (*Task, error) {
|
||||
f.calls++
|
||||
f.task = task
|
||||
return &f.task, f.err
|
||||
}
|
||||
func (f *fakeTasks) Update(ctx context.Context, task Task) (*Task, error) { return f.Create(ctx, task) }
|
||||
func (f *fakeTasks) SetStatus(_ context.Context, id, version int, status string) (*Task, error) {
|
||||
f.calls++
|
||||
f.task.ID, f.task.Version, f.task.Status = id, version, status
|
||||
return &f.task, f.err
|
||||
}
|
||||
func (f *fakeTasks) Delete(context.Context, int, int) error { f.calls++; return f.err }
|
||||
|
||||
func TestTaskValidationAndErrors(t *testing.T) {
|
||||
zero := 0
|
||||
tests := []struct {
|
||||
name string
|
||||
task Task
|
||||
repoErr error
|
||||
wantErr error
|
||||
wantCalls int
|
||||
}{
|
||||
{name: "default status and trimmed title", task: Task{Title: " Задача "}, wantCalls: 1},
|
||||
{name: "unicode limit", task: Task{Title: strings.Repeat("Я", 255)}, wantCalls: 1},
|
||||
{name: "NUL in title", task: Task{Title: "Task\x00"}, wantErr: ErrInvalidTask},
|
||||
{name: "NUL in description", task: Task{Title: "Task", Description: "\x00"}, wantErr: ErrInvalidTask},
|
||||
{name: "blank title", task: Task{Title: " "}, wantErr: ErrInvalidTask},
|
||||
{name: "long title", task: Task{Title: strings.Repeat("Я", 256)}, wantErr: ErrInvalidTask},
|
||||
{name: "long description", task: Task{Title: "Task", Description: strings.Repeat("Я", 10001)}, wantErr: ErrInvalidTask},
|
||||
{name: "unknown status", task: Task{Title: "Task", Status: "cancelled"}, wantErr: ErrInvalidTask},
|
||||
{name: "invalid assignee ID", task: Task{Title: "Task", AssigneeID: &zero}, wantErr: ErrInvalidTask},
|
||||
{name: "ineligible assignee", task: Task{Title: "Task"}, repoErr: ErrInvalidAssignee, wantErr: ErrInvalidAssignee, wantCalls: 1},
|
||||
}
|
||||
for _, tc := range tests {
|
||||
t.Run(tc.name, func(t *testing.T) {
|
||||
repo := &fakeTasks{err: tc.repoErr}
|
||||
_, err := NewTaskService(repo).Create(context.Background(), tc.task)
|
||||
if !errors.Is(err, tc.wantErr) || repo.calls != tc.wantCalls {
|
||||
t.Fatalf("error=%v calls=%d", err, repo.calls)
|
||||
}
|
||||
if err == nil && (repo.task.Title != strings.TrimSpace(tc.task.Title) || repo.task.Status != "new") {
|
||||
t.Fatalf("saved task=%+v", repo.task)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestWritesValidateVersionAndPropagateErrors(t *testing.T) {
|
||||
for _, operation := range []string{"update", "status", "delete"} {
|
||||
for _, tc := range []struct {
|
||||
name string
|
||||
id, version int
|
||||
repoErr, wantErr error
|
||||
}{
|
||||
{"valid", 1, 1, nil, nil},
|
||||
{"invalid ID", 0, 1, nil, ErrInvalidTask},
|
||||
{"invalid version", 1, 0, nil, ErrInvalidTask},
|
||||
{"conflict", 1, 1, ErrConflict, ErrConflict},
|
||||
{"missing", 1, 1, ErrNotFound, ErrNotFound},
|
||||
} {
|
||||
t.Run(operation+"/"+tc.name, func(t *testing.T) {
|
||||
repo := &fakeTasks{err: tc.repoErr}
|
||||
service := NewTaskService(repo)
|
||||
var err error
|
||||
switch operation {
|
||||
case "update":
|
||||
_, err = service.Update(context.Background(), Task{ID: tc.id, Version: tc.version, Title: "Task", Status: "new"})
|
||||
case "status":
|
||||
_, err = service.SetStatus(context.Background(), tc.id, tc.version, "review")
|
||||
case "delete":
|
||||
err = service.Delete(context.Background(), tc.id, tc.version)
|
||||
}
|
||||
if !errors.Is(err, tc.wantErr) {
|
||||
t.Fatalf("error=%v want=%v", err, tc.wantErr)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestStatusTransitionsAllowAllFourStates(t *testing.T) {
|
||||
for _, status := range []string{"new", "in_progress", "review", "done", "unknown"} {
|
||||
t.Run(status, func(t *testing.T) {
|
||||
repo := &fakeTasks{}
|
||||
_, err := NewTaskService(repo).SetStatus(context.Background(), 1, 1, status)
|
||||
if status == "unknown" {
|
||||
if !errors.Is(err, ErrInvalidTask) || repo.calls != 0 {
|
||||
t.Fatalf("error=%v calls=%d", err, repo.calls)
|
||||
}
|
||||
} else if err != nil || repo.task.Status != status {
|
||||
t.Fatalf("error=%v task=%+v", err, repo.task)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestDueDatesRemainCalendarDates(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
value string
|
||||
valid bool
|
||||
}{
|
||||
{"", true}, {"2026-10-07", true}, {"2024-02-29", true}, {"2026-02-29", false},
|
||||
{"2026-10-07T00:00:00Z", false}, {"2026-1-2", false}, {"0000-01-01", false},
|
||||
} {
|
||||
t.Run(tc.value, func(t *testing.T) {
|
||||
date, err := ParseDueDate(tc.value)
|
||||
if tc.valid {
|
||||
if err != nil || (tc.value != "" && date.Format("2006-01-02") != tc.value) || (tc.value == "" && date != nil) {
|
||||
t.Fatalf("date=%v err=%v", date, err)
|
||||
}
|
||||
} else if !errors.Is(err, ErrInvalidTask) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -12,6 +12,9 @@ var (
|
||||
"users_page",
|
||||
"reviews_page",
|
||||
},
|
||||
rolesModule.Developer: {
|
||||
"tasks_page",
|
||||
},
|
||||
rolesModule.Author: {
|
||||
"scenarios_page",
|
||||
"scenario_editor_page",
|
||||
|
||||
@@ -0,0 +1,25 @@
|
||||
package ui_service
|
||||
|
||||
import (
|
||||
"slices"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTasksPermission(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
role string
|
||||
allowed bool
|
||||
}{
|
||||
{"developer", true}, {"admin", true}, {"user", false}, {"author", false}, {"organizer", false},
|
||||
} {
|
||||
t.Run(tc.role, func(t *testing.T) {
|
||||
got := NewUIService().GetPermissions([]string{tc.role})
|
||||
if slices.Contains(got, "tasks_page") != tc.allowed {
|
||||
t.Fatalf("permissions=%v", got)
|
||||
}
|
||||
if tc.role == "developer" && slices.Contains(got, "users_page") {
|
||||
t.Fatal("developer has administrative permission")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package users_service
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestDeveloperRoleCanBeAssignedAndRemoved(t *testing.T) {
|
||||
for _, tc := range []struct {
|
||||
role string
|
||||
wantErr error
|
||||
}{
|
||||
{"developer", nil}, {"invalid", ErrInvalidRole},
|
||||
} {
|
||||
t.Run(tc.role, func(t *testing.T) {
|
||||
service := NewUsersService(&fakeRepo{}, nil, nil, nil, nil, "")
|
||||
for _, change := range []func(context.Context, int, string) error{service.AddUserRole, service.DeleteUserRole} {
|
||||
if err := change(context.Background(), 1, tc.role); !errors.Is(err, tc.wantErr) {
|
||||
t.Fatalf("error=%v", err)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
-- +goose Up
|
||||
CREATE TABLE developer_tasks (
|
||||
id SERIAL PRIMARY KEY,
|
||||
title VARCHAR(255) NOT NULL CHECK (char_length(btrim(title)) > 0),
|
||||
description TEXT NOT NULL DEFAULT '' CHECK (char_length(description) <= 10000),
|
||||
status TEXT NOT NULL DEFAULT 'new' CHECK (status IN ('new', 'in_progress', 'review', 'done')),
|
||||
assignee_id INTEGER REFERENCES users(id) ON DELETE SET NULL,
|
||||
author_id INTEGER REFERENCES users(id) ON DELETE SET NULL,
|
||||
due_date DATE,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
|
||||
version INTEGER NOT NULL DEFAULT 1 CHECK (version > 0)
|
||||
);
|
||||
|
||||
-- +goose Down
|
||||
DROP TABLE developer_tasks;
|
||||
+1026
-221
File diff suppressed because it is too large
Load Diff
@@ -36,6 +36,210 @@ var (
|
||||
_ = metadata.Join
|
||||
)
|
||||
|
||||
func request_EveningDetectiveServer_GetTasks_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq GetTasksReq
|
||||
metadata runtime.ServerMetadata
|
||||
)
|
||||
if req.Body != nil {
|
||||
_, _ = io.Copy(io.Discard, req.Body)
|
||||
}
|
||||
msg, err := client.GetTasks(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func local_request_EveningDetectiveServer_GetTasks_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq GetTasksReq
|
||||
metadata runtime.ServerMetadata
|
||||
)
|
||||
msg, err := server.GetTasks(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func request_EveningDetectiveServer_GetTaskAssignees_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq GetTaskAssigneesReq
|
||||
metadata runtime.ServerMetadata
|
||||
)
|
||||
if req.Body != nil {
|
||||
_, _ = io.Copy(io.Discard, req.Body)
|
||||
}
|
||||
msg, err := client.GetTaskAssignees(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func local_request_EveningDetectiveServer_GetTaskAssignees_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq GetTaskAssigneesReq
|
||||
metadata runtime.ServerMetadata
|
||||
)
|
||||
msg, err := server.GetTaskAssignees(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func request_EveningDetectiveServer_CreateTask_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq CreateTaskReq
|
||||
metadata runtime.ServerMetadata
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if req.Body != nil {
|
||||
_, _ = io.Copy(io.Discard, req.Body)
|
||||
}
|
||||
msg, err := client.CreateTask(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func local_request_EveningDetectiveServer_CreateTask_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq CreateTaskReq
|
||||
metadata runtime.ServerMetadata
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
msg, err := server.CreateTask(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func request_EveningDetectiveServer_UpdateTask_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq UpdateTaskReq
|
||||
metadata runtime.ServerMetadata
|
||||
err error
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if req.Body != nil {
|
||||
_, _ = io.Copy(io.Discard, req.Body)
|
||||
}
|
||||
val, ok := pathParams["ID"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "ID")
|
||||
}
|
||||
protoReq.ID, err = runtime.Int32(val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "ID", err)
|
||||
}
|
||||
msg, err := client.UpdateTask(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func local_request_EveningDetectiveServer_UpdateTask_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq UpdateTaskReq
|
||||
metadata runtime.ServerMetadata
|
||||
err error
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
val, ok := pathParams["ID"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "ID")
|
||||
}
|
||||
protoReq.ID, err = runtime.Int32(val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "ID", err)
|
||||
}
|
||||
msg, err := server.UpdateTask(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func request_EveningDetectiveServer_SetTaskStatus_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq SetTaskStatusReq
|
||||
metadata runtime.ServerMetadata
|
||||
err error
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if req.Body != nil {
|
||||
_, _ = io.Copy(io.Discard, req.Body)
|
||||
}
|
||||
val, ok := pathParams["ID"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "ID")
|
||||
}
|
||||
protoReq.ID, err = runtime.Int32(val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "ID", err)
|
||||
}
|
||||
msg, err := client.SetTaskStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func local_request_EveningDetectiveServer_SetTaskStatus_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq SetTaskStatusReq
|
||||
metadata runtime.ServerMetadata
|
||||
err error
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
val, ok := pathParams["ID"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "ID")
|
||||
}
|
||||
protoReq.ID, err = runtime.Int32(val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "ID", err)
|
||||
}
|
||||
msg, err := server.SetTaskStatus(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func request_EveningDetectiveServer_DeleteTask_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq DeleteTaskReq
|
||||
metadata runtime.ServerMetadata
|
||||
err error
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
if req.Body != nil {
|
||||
_, _ = io.Copy(io.Discard, req.Body)
|
||||
}
|
||||
val, ok := pathParams["ID"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "ID")
|
||||
}
|
||||
protoReq.ID, err = runtime.Int32(val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "ID", err)
|
||||
}
|
||||
msg, err := client.DeleteTask(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func local_request_EveningDetectiveServer_DeleteTask_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq DeleteTaskReq
|
||||
metadata runtime.ServerMetadata
|
||||
err error
|
||||
)
|
||||
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
||||
}
|
||||
val, ok := pathParams["ID"]
|
||||
if !ok {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "ID")
|
||||
}
|
||||
protoReq.ID, err = runtime.Int32(val)
|
||||
if err != nil {
|
||||
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "ID", err)
|
||||
}
|
||||
msg, err := server.DeleteTask(ctx, &protoReq)
|
||||
return msg, metadata, err
|
||||
}
|
||||
|
||||
func request_EveningDetectiveServer_GetParticipation_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
||||
var (
|
||||
protoReq GetParticipationReq
|
||||
@@ -3836,6 +4040,126 @@ func local_request_EveningDetectiveServer_SetTeamAnswerScore_0(ctx context.Conte
|
||||
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterEveningDetectiveServerHandlerFromEndpoint instead.
|
||||
// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.
|
||||
func RegisterEveningDetectiveServerHandlerServer(ctx context.Context, mux *runtime.ServeMux, server EveningDetectiveServerServer) error {
|
||||
mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetTasks_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
var stream runtime.ServerTransportStream
|
||||
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/GetTasks", runtime.WithHTTPPathPattern("/api/tasks"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_EveningDetectiveServer_GetTasks_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
||||
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_GetTasks_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetTaskAssignees_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
var stream runtime.ServerTransportStream
|
||||
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/GetTaskAssignees", runtime.WithHTTPPathPattern("/api/tasks/assignees"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_EveningDetectiveServer_GetTaskAssignees_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
||||
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_GetTaskAssignees_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_CreateTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
var stream runtime.ServerTransportStream
|
||||
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/CreateTask", runtime.WithHTTPPathPattern("/api/tasks"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_EveningDetectiveServer_CreateTask_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
||||
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_CreateTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPut, pattern_EveningDetectiveServer_UpdateTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
var stream runtime.ServerTransportStream
|
||||
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/UpdateTask", runtime.WithHTTPPathPattern("/api/tasks/{ID}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_EveningDetectiveServer_UpdateTask_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
||||
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_UpdateTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_SetTaskStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
var stream runtime.ServerTransportStream
|
||||
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/SetTaskStatus", runtime.WithHTTPPathPattern("/api/tasks/{ID}/status"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_EveningDetectiveServer_SetTaskStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
||||
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_SetTaskStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_DeleteTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
var stream runtime.ServerTransportStream
|
||||
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/DeleteTask", runtime.WithHTTPPathPattern("/api/tasks/{ID}/delete"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := local_request_EveningDetectiveServer_DeleteTask_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
||||
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_DeleteTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_GetParticipation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
@@ -5836,6 +6160,108 @@ func RegisterEveningDetectiveServerHandler(ctx context.Context, mux *runtime.Ser
|
||||
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
||||
// "EveningDetectiveServerClient" to call the correct interceptors. This client ignores the HTTP middlewares.
|
||||
func RegisterEveningDetectiveServerHandlerClient(ctx context.Context, mux *runtime.ServeMux, client EveningDetectiveServerClient) error {
|
||||
mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetTasks_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/GetTasks", runtime.WithHTTPPathPattern("/api/tasks"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_EveningDetectiveServer_GetTasks_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_GetTasks_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetTaskAssignees_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/GetTaskAssignees", runtime.WithHTTPPathPattern("/api/tasks/assignees"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_EveningDetectiveServer_GetTaskAssignees_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_GetTaskAssignees_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_CreateTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/CreateTask", runtime.WithHTTPPathPattern("/api/tasks"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_EveningDetectiveServer_CreateTask_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_CreateTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPut, pattern_EveningDetectiveServer_UpdateTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/UpdateTask", runtime.WithHTTPPathPattern("/api/tasks/{ID}"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_EveningDetectiveServer_UpdateTask_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_UpdateTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_SetTaskStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/SetTaskStatus", runtime.WithHTTPPathPattern("/api/tasks/{ID}/status"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_EveningDetectiveServer_SetTaskStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_SetTaskStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_DeleteTask_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
||||
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/crabs.evening_detective_server.EveningDetectiveServer/DeleteTask", runtime.WithHTTPPathPattern("/api/tasks/{ID}/delete"))
|
||||
if err != nil {
|
||||
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
resp, md, err := request_EveningDetectiveServer_DeleteTask_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
||||
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
||||
if err != nil {
|
||||
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
||||
return
|
||||
}
|
||||
forward_EveningDetectiveServer_DeleteTask_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
||||
})
|
||||
mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_GetParticipation_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
||||
ctx, cancel := context.WithCancel(req.Context())
|
||||
defer cancel()
|
||||
@@ -7506,6 +7932,12 @@ func RegisterEveningDetectiveServerHandlerClient(ctx context.Context, mux *runti
|
||||
}
|
||||
|
||||
var (
|
||||
pattern_EveningDetectiveServer_GetTasks_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"api", "tasks"}, ""))
|
||||
pattern_EveningDetectiveServer_GetTaskAssignees_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "tasks", "assignees"}, ""))
|
||||
pattern_EveningDetectiveServer_CreateTask_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"api", "tasks"}, ""))
|
||||
pattern_EveningDetectiveServer_UpdateTask_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"api", "tasks", "ID"}, ""))
|
||||
pattern_EveningDetectiveServer_SetTaskStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"api", "tasks", "ID", "status"}, ""))
|
||||
pattern_EveningDetectiveServer_DeleteTask_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"api", "tasks", "ID", "delete"}, ""))
|
||||
pattern_EveningDetectiveServer_GetParticipation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "participation", "get"}, ""))
|
||||
pattern_EveningDetectiveServer_AnswerParticipation_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "participation", "answer"}, ""))
|
||||
pattern_EveningDetectiveServer_Ping_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "test", "ping"}, ""))
|
||||
@@ -7607,6 +8039,12 @@ var (
|
||||
)
|
||||
|
||||
var (
|
||||
forward_EveningDetectiveServer_GetTasks_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_GetTaskAssignees_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_CreateTask_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_UpdateTask_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_SetTaskStatus_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_DeleteTask_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_GetParticipation_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_AnswerParticipation_0 = runtime.ForwardResponseMessage
|
||||
forward_EveningDetectiveServer_Ping_0 = runtime.ForwardResponseMessage
|
||||
|
||||
@@ -26,6 +26,12 @@ import (
|
||||
const _ = grpc.SupportPackageIsVersion9
|
||||
|
||||
const (
|
||||
EveningDetectiveServer_GetTasks_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/GetTasks"
|
||||
EveningDetectiveServer_GetTaskAssignees_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/GetTaskAssignees"
|
||||
EveningDetectiveServer_CreateTask_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/CreateTask"
|
||||
EveningDetectiveServer_UpdateTask_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/UpdateTask"
|
||||
EveningDetectiveServer_SetTaskStatus_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/SetTaskStatus"
|
||||
EveningDetectiveServer_DeleteTask_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteTask"
|
||||
EveningDetectiveServer_GetParticipation_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/GetParticipation"
|
||||
EveningDetectiveServer_AnswerParticipation_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/AnswerParticipation"
|
||||
EveningDetectiveServer_Ping_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/Ping"
|
||||
@@ -130,6 +136,12 @@ const (
|
||||
//
|
||||
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
|
||||
type EveningDetectiveServerClient interface {
|
||||
GetTasks(ctx context.Context, in *GetTasksReq, opts ...grpc.CallOption) (*GetTasksRsp, error)
|
||||
GetTaskAssignees(ctx context.Context, in *GetTaskAssigneesReq, opts ...grpc.CallOption) (*GetTaskAssigneesRsp, error)
|
||||
CreateTask(ctx context.Context, in *CreateTaskReq, opts ...grpc.CallOption) (*TaskRsp, error)
|
||||
UpdateTask(ctx context.Context, in *UpdateTaskReq, opts ...grpc.CallOption) (*TaskRsp, error)
|
||||
SetTaskStatus(ctx context.Context, in *SetTaskStatusReq, opts ...grpc.CallOption) (*TaskRsp, error)
|
||||
DeleteTask(ctx context.Context, in *DeleteTaskReq, opts ...grpc.CallOption) (*DeleteTaskRsp, error)
|
||||
GetParticipation(ctx context.Context, in *GetParticipationReq, opts ...grpc.CallOption) (*ParticipationRsp, error)
|
||||
AnswerParticipation(ctx context.Context, in *AnswerParticipationReq, opts ...grpc.CallOption) (*ParticipationRsp, error)
|
||||
Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingRsp, error)
|
||||
@@ -248,6 +260,66 @@ func NewEveningDetectiveServerClient(cc grpc.ClientConnInterface) EveningDetecti
|
||||
return &eveningDetectiveServerClient{cc}
|
||||
}
|
||||
|
||||
func (c *eveningDetectiveServerClient) GetTasks(ctx context.Context, in *GetTasksReq, opts ...grpc.CallOption) (*GetTasksRsp, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(GetTasksRsp)
|
||||
err := c.cc.Invoke(ctx, EveningDetectiveServer_GetTasks_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *eveningDetectiveServerClient) GetTaskAssignees(ctx context.Context, in *GetTaskAssigneesReq, opts ...grpc.CallOption) (*GetTaskAssigneesRsp, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(GetTaskAssigneesRsp)
|
||||
err := c.cc.Invoke(ctx, EveningDetectiveServer_GetTaskAssignees_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *eveningDetectiveServerClient) CreateTask(ctx context.Context, in *CreateTaskReq, opts ...grpc.CallOption) (*TaskRsp, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(TaskRsp)
|
||||
err := c.cc.Invoke(ctx, EveningDetectiveServer_CreateTask_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *eveningDetectiveServerClient) UpdateTask(ctx context.Context, in *UpdateTaskReq, opts ...grpc.CallOption) (*TaskRsp, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(TaskRsp)
|
||||
err := c.cc.Invoke(ctx, EveningDetectiveServer_UpdateTask_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *eveningDetectiveServerClient) SetTaskStatus(ctx context.Context, in *SetTaskStatusReq, opts ...grpc.CallOption) (*TaskRsp, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(TaskRsp)
|
||||
err := c.cc.Invoke(ctx, EveningDetectiveServer_SetTaskStatus_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *eveningDetectiveServerClient) DeleteTask(ctx context.Context, in *DeleteTaskReq, opts ...grpc.CallOption) (*DeleteTaskRsp, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(DeleteTaskRsp)
|
||||
err := c.cc.Invoke(ctx, EveningDetectiveServer_DeleteTask_FullMethodName, in, out, cOpts...)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return out, nil
|
||||
}
|
||||
|
||||
func (c *eveningDetectiveServerClient) GetParticipation(ctx context.Context, in *GetParticipationReq, opts ...grpc.CallOption) (*ParticipationRsp, error) {
|
||||
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
|
||||
out := new(ParticipationRsp)
|
||||
@@ -1232,6 +1304,12 @@ func (c *eveningDetectiveServerClient) SetTeamAnswerScore(ctx context.Context, i
|
||||
// All implementations must embed UnimplementedEveningDetectiveServerServer
|
||||
// for forward compatibility.
|
||||
type EveningDetectiveServerServer interface {
|
||||
GetTasks(context.Context, *GetTasksReq) (*GetTasksRsp, error)
|
||||
GetTaskAssignees(context.Context, *GetTaskAssigneesReq) (*GetTaskAssigneesRsp, error)
|
||||
CreateTask(context.Context, *CreateTaskReq) (*TaskRsp, error)
|
||||
UpdateTask(context.Context, *UpdateTaskReq) (*TaskRsp, error)
|
||||
SetTaskStatus(context.Context, *SetTaskStatusReq) (*TaskRsp, error)
|
||||
DeleteTask(context.Context, *DeleteTaskReq) (*DeleteTaskRsp, error)
|
||||
GetParticipation(context.Context, *GetParticipationReq) (*ParticipationRsp, error)
|
||||
AnswerParticipation(context.Context, *AnswerParticipationReq) (*ParticipationRsp, error)
|
||||
Ping(context.Context, *PingReq) (*PingRsp, error)
|
||||
@@ -1350,6 +1428,24 @@ type EveningDetectiveServerServer interface {
|
||||
// pointer dereference when methods are called.
|
||||
type UnimplementedEveningDetectiveServerServer struct{}
|
||||
|
||||
func (UnimplementedEveningDetectiveServerServer) GetTasks(context.Context, *GetTasksReq) (*GetTasksRsp, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method GetTasks not implemented")
|
||||
}
|
||||
func (UnimplementedEveningDetectiveServerServer) GetTaskAssignees(context.Context, *GetTaskAssigneesReq) (*GetTaskAssigneesRsp, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method GetTaskAssignees not implemented")
|
||||
}
|
||||
func (UnimplementedEveningDetectiveServerServer) CreateTask(context.Context, *CreateTaskReq) (*TaskRsp, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method CreateTask not implemented")
|
||||
}
|
||||
func (UnimplementedEveningDetectiveServerServer) UpdateTask(context.Context, *UpdateTaskReq) (*TaskRsp, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method UpdateTask not implemented")
|
||||
}
|
||||
func (UnimplementedEveningDetectiveServerServer) SetTaskStatus(context.Context, *SetTaskStatusReq) (*TaskRsp, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method SetTaskStatus not implemented")
|
||||
}
|
||||
func (UnimplementedEveningDetectiveServerServer) DeleteTask(context.Context, *DeleteTaskReq) (*DeleteTaskRsp, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method DeleteTask not implemented")
|
||||
}
|
||||
func (UnimplementedEveningDetectiveServerServer) GetParticipation(context.Context, *GetParticipationReq) (*ParticipationRsp, error) {
|
||||
return nil, status.Error(codes.Unimplemented, "method GetParticipation not implemented")
|
||||
}
|
||||
@@ -1666,6 +1762,114 @@ func RegisterEveningDetectiveServerServer(s grpc.ServiceRegistrar, srv EveningDe
|
||||
s.RegisterService(&EveningDetectiveServer_ServiceDesc, srv)
|
||||
}
|
||||
|
||||
func _EveningDetectiveServer_GetTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetTasksReq)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EveningDetectiveServerServer).GetTasks(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: EveningDetectiveServer_GetTasks_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EveningDetectiveServerServer).GetTasks(ctx, req.(*GetTasksReq))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _EveningDetectiveServer_GetTaskAssignees_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetTaskAssigneesReq)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EveningDetectiveServerServer).GetTaskAssignees(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: EveningDetectiveServer_GetTaskAssignees_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EveningDetectiveServerServer).GetTaskAssignees(ctx, req.(*GetTaskAssigneesReq))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _EveningDetectiveServer_CreateTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(CreateTaskReq)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EveningDetectiveServerServer).CreateTask(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: EveningDetectiveServer_CreateTask_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EveningDetectiveServerServer).CreateTask(ctx, req.(*CreateTaskReq))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _EveningDetectiveServer_UpdateTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(UpdateTaskReq)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EveningDetectiveServerServer).UpdateTask(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: EveningDetectiveServer_UpdateTask_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EveningDetectiveServerServer).UpdateTask(ctx, req.(*UpdateTaskReq))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _EveningDetectiveServer_SetTaskStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(SetTaskStatusReq)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EveningDetectiveServerServer).SetTaskStatus(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: EveningDetectiveServer_SetTaskStatus_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EveningDetectiveServerServer).SetTaskStatus(ctx, req.(*SetTaskStatusReq))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _EveningDetectiveServer_DeleteTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(DeleteTaskReq)
|
||||
if err := dec(in); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if interceptor == nil {
|
||||
return srv.(EveningDetectiveServerServer).DeleteTask(ctx, in)
|
||||
}
|
||||
info := &grpc.UnaryServerInfo{
|
||||
Server: srv,
|
||||
FullMethod: EveningDetectiveServer_DeleteTask_FullMethodName,
|
||||
}
|
||||
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
|
||||
return srv.(EveningDetectiveServerServer).DeleteTask(ctx, req.(*DeleteTaskReq))
|
||||
}
|
||||
return interceptor(ctx, in, info, handler)
|
||||
}
|
||||
|
||||
func _EveningDetectiveServer_GetParticipation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
|
||||
in := new(GetParticipationReq)
|
||||
if err := dec(in); err != nil {
|
||||
@@ -3437,6 +3641,30 @@ var EveningDetectiveServer_ServiceDesc = grpc.ServiceDesc{
|
||||
ServiceName: "crabs.evening_detective_server.EveningDetectiveServer",
|
||||
HandlerType: (*EveningDetectiveServerServer)(nil),
|
||||
Methods: []grpc.MethodDesc{
|
||||
{
|
||||
MethodName: "GetTasks",
|
||||
Handler: _EveningDetectiveServer_GetTasks_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetTaskAssignees",
|
||||
Handler: _EveningDetectiveServer_GetTaskAssignees_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "CreateTask",
|
||||
Handler: _EveningDetectiveServer_CreateTask_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "UpdateTask",
|
||||
Handler: _EveningDetectiveServer_UpdateTask_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "SetTaskStatus",
|
||||
Handler: _EveningDetectiveServer_SetTaskStatus_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "DeleteTask",
|
||||
Handler: _EveningDetectiveServer_DeleteTask_Handler,
|
||||
},
|
||||
{
|
||||
MethodName: "GetParticipation",
|
||||
Handler: _EveningDetectiveServer_GetParticipation_Handler,
|
||||
|
||||
Reference in New Issue
Block a user