add scenarios methods

api/main.proto

@@ -197,6 +197,90 @@ service EveningDetectiveServer {
       summary: "Получить файл";
     };
   }
+
+  rpc AddScenario(AddScenarioReq) returns (AddScenarioRsp) {
+    option (google.api.http) = {
+      post: "/api/scenario"
+      body: "*"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Сценарии";
+      summary: "Создать сценарий";
+    };
+  }
+
+  rpc GetMyScenarios(GetMyScenariosReq) returns (GetMyScenariosRsp) {
+    option (google.api.http) = {
+      get: "/api/my-scenarios"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Сценарии";
+      summary: "Получить свои сценарии";
+    };
+  }
+
+  rpc GetScenario(GetScenarioReq) returns (GetScenarioRsp) {
+    option (google.api.http) = {
+      get: "/api/scenarios/{id}"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Сценарии";
+      summary: "Получить сценарий по id";
+    };
+  }
+
+  rpc UpdateScenario(UpdateScenarioReq) returns (UpdateScenarioRsp) {
+    option (google.api.http) = {
+      put : "/api/scenarios/{id}"
+      body: "*"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Сценарии";
+      summary: "Редактировать сценарий";
+    };
+  }
+
+  rpc DeleteScenario(DeleteScenarioReq) returns (DeleteScenarioRsp) {
+    option (google.api.http) = {
+      delete: "/api/scenarios/{id}"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Сценарии";
+      summary: "Удалить сценарий";
+    };
+  }
+
+  rpc AddScenarioPlace(AddScenarioPlaceReq) returns (AddScenarioPlaceRsp) {
+    option (google.api.http) = {
+      post: "/api/scenarios/places"
+      body: "*"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Точки сценария";
+      summary: "Создать точку сценария";
+    };
+  }
+
+  rpc UpdateScenarioPlace(UpdateScenarioPlaceReq) returns (UpdateScenarioPlaceRsp) {
+    option (google.api.http) = {
+      put : "/api/scenarios/places/{code}"
+      body: "*"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Точки сценария";
+      summary: "Обновить точку сценария";
+    };
+  }
+
+  rpc DeleteScenarioPlace(DeleteScenarioPlaceReq) returns (DeleteScenarioPlaceRsp) {
+    option (google.api.http) = {
+      delete: "/api/scenarios/places/{code}"
+    };
+    option (grpc.gateway.protoc_gen_openapiv2.options.openapiv2_operation) = {
+      tags   : "Точки сценария";
+      summary: "Удалить точку сценария";
+    };
+  }
 }
 
 message PingReq {}
@@ -319,3 +403,114 @@ message UploadFileRsp {
 message DownloadFileReq {
   string filename = 1;
 }
+
+message AddScenarioReq {
+  string name = 1;
+}
+
+message AddScenarioRsp {
+  string error = 1;
+  int32  id    = 2;
+}
+
+message GetMyScenariosReq {}
+
+message GetMyScenariosRsp {
+  string            error     = 1;
+  repeated Scenario scenarios = 2;
+}
+
+message GetScenarioReq {
+  int32 id = 1;
+}
+
+message GetScenarioRsp {
+  string error = 1;
+  Scenario scenario = 2;
+}
+
+message Scenario {
+  int32                     id           = 1;
+  string                    name         = 2;
+  optional string           description  = 3;
+  optional string           image        = 4;
+  Story                     story        = 5;
+  User                      author       = 6;
+  google.protobuf.Timestamp updated_at   = 7;
+  google.protobuf.Timestamp created_at   = 8;
+  google.protobuf.Timestamp published_at = 9;
+}
+
+message Story {
+  repeated Place places = 1;
+}
+
+message Place {
+  string               code         = 1;
+  string               name         = 2;
+  string               text         = 3;
+  string               image        = 4;
+  bool                 hidden       = 5;
+  repeated Application applications = 6;
+  repeated Door        doors        = 7;
+  repeated Key         keys         = 8;
+}
+
+message Application {
+  string name  = 1;
+  string image = 2;
+}
+
+message Door {
+  string       code = 1;
+  string       name = 2;
+  repeated Key keys = 3;
+}
+
+message Key {
+  string name = 1;
+}
+
+message UpdateScenarioReq {
+  int32  id          = 1;
+  string name        = 2;
+  string description = 3;
+  string image       = 4;
+}
+
+message UpdateScenarioRsp {
+  string error = 1;
+}
+
+message DeleteScenarioReq {
+  int32 id = 1;
+}
+
+message DeleteScenarioRsp {
+  string error = 1;
+}
+
+message AddScenarioPlaceReq {
+  Place place = 1;
+}
+
+message AddScenarioPlaceRsp {
+  string error = 1;
+}
+
+message UpdateScenarioPlaceReq {
+  string code  = 1;
+  Place  place = 2;
+}
+
+message UpdateScenarioPlaceRsp {
+  string error = 1;
+}
+
+message DeleteScenarioPlaceReq {
+  string code = 1;
+}
+
+message DeleteScenarioPlaceRsp {
+  string error = 1;
+}

cmd/evening_detective_server/main.go

@@ -9,8 +9,10 @@ import (
 	"evening_detective_server/internal/modules/password_generator"
 	"evening_detective_server/internal/modules/processor_jwt"
 	"evening_detective_server/internal/repos/refresh_tokens_repo"
+	"evening_detective_server/internal/repos/scenarios_repo"
 	"evening_detective_server/internal/repos/users_repo"
 	"evening_detective_server/internal/services/file_service"
+	"evening_detective_server/internal/services/scenarios_service"
 	"evening_detective_server/internal/services/ui_service"
 	"evening_detective_server/internal/services/users_service"
 	proto "evening_detective_server/proto"
@@ -69,6 +71,8 @@ func main() {
 		log.Fatalf("Unable to create connection rustfs: %v\n", err)
 	}
 	fileService := file_service.NewFileService(fileStorage)
+	scenariosRepo := scenarios_repo.NewScenariosRepo(dbpool)
+	scenarioService := scenarios_service.NewScenarioService(scenariosRepo)
 
 	// Create a listener on TCP port
 	lis, err := net.Listen("tcp", ":8080")
@@ -100,6 +104,7 @@ func main() {
 			usersService,
 			uiService,
 			fileService,
+			scenarioService,
 		),
 	)
 	// Serve gRPC server

cmd/evening_detective_server/main.swagger.json

@@ -232,6 +232,263 @@
         ]
       }
     },
+    "/api/my-scenarios": {
+      "get": {
+        "summary": "Получить свои сценарии",
+        "operationId": "EveningDetectiveServer_GetMyScenarios",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverGetMyScenariosRsp"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "tags": [
+          "Сценарии"
+        ]
+      }
+    },
+    "/api/scenario": {
+      "post": {
+        "summary": "Создать сценарий",
+        "operationId": "EveningDetectiveServer_AddScenario",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverAddScenarioRsp"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverAddScenarioReq"
+            }
+          }
+        ],
+        "tags": [
+          "Сценарии"
+        ]
+      }
+    },
+    "/api/scenarios/places": {
+      "post": {
+        "summary": "Создать точку сценария",
+        "operationId": "EveningDetectiveServer_AddScenarioPlace",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverAddScenarioPlaceRsp"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverAddScenarioPlaceReq"
+            }
+          }
+        ],
+        "tags": [
+          "Точки сценария"
+        ]
+      }
+    },
+    "/api/scenarios/places/{code}": {
+      "delete": {
+        "summary": "Удалить точку сценария",
+        "operationId": "EveningDetectiveServer_DeleteScenarioPlace",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverDeleteScenarioPlaceRsp"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "code",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          }
+        ],
+        "tags": [
+          "Точки сценария"
+        ]
+      },
+      "put": {
+        "summary": "Обновить точку сценария",
+        "operationId": "EveningDetectiveServer_UpdateScenarioPlace",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverUpdateScenarioPlaceRsp"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "code",
+            "in": "path",
+            "required": true,
+            "type": "string"
+          },
+          {
+            "name": "body",
+            "in": "body",
+            "required": true,
+            "schema": {
+              "$ref": "#/definitions/EveningDetectiveServerUpdateScenarioPlaceBody"
+            }
+          }
+        ],
+        "tags": [
+          "Точки сценария"
+        ]
+      }
+    },
+    "/api/scenarios/{id}": {
+      "get": {
+        "summary": "Получить сценарий по id",
+        "operationId": "EveningDetectiveServer_GetScenario",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverGetScenarioRsp"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "type": "integer",
+            "format": "int32"
+          }
+        ],
+        "tags": [
+          "Сценарии"
+        ]
+      },
+      "delete": {
+        "summary": "Удалить сценарий",
+        "operationId": "EveningDetectiveServer_DeleteScenario",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverDeleteScenarioRsp"
+            }
+          },
+          "default": {
+            "description": "An unexpected error response.",
+            "schema": {
+              "$ref": "#/definitions/rpcStatus"
+            }
+          }
+        },
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "type": "integer",
+            "format": "int32"
+          }
+        ],
+        "tags": [
+          "Сценарии"
+        ]
+      },
+      "put": {
+        "summary": "Редактировать сценарий",
+        "operationId": "EveningDetectiveServer_UpdateScenario",
+        "responses": {
+          "200": {
+            "description": "A successful response.",
+            "schema": {
+              "$ref": "#/definitions/evening_detective_serverUpdateScenarioRsp"
+            }
+          },
+          "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/EveningDetectiveServerUpdateScenarioBody"
+            }
+          }
+        ],
+        "tags": [
+          "Сценарии"
+        ]
+      }
+    },
     "/api/test/echo": {
       "post": {
         "summary": "Проверить обработку данных",
@@ -495,6 +752,28 @@
         }
       }
     },
+    "EveningDetectiveServerUpdateScenarioBody": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "image": {
+          "type": "string"
+        }
+      }
+    },
+    "EveningDetectiveServerUpdateScenarioPlaceBody": {
+      "type": "object",
+      "properties": {
+        "place": {
+          "$ref": "#/definitions/evening_detective_serverPlace"
+        }
+      }
+    },
     "apiHttpBody": {
       "type": "object",
       "properties": {
@@ -518,6 +797,42 @@
       },
       "description": "Message that represents an arbitrary HTTP body. It should only be used for\npayload formats that can't be represented as JSON, such as raw binary or\nan HTML page.\n\n\nThis message can be used both in streaming and non-streaming API methods in\nthe request as well as the response.\n\nIt can be used as a top-level request field, which is convenient if one\nwants to extract parameters from either the URL or HTTP template into the\nrequest fields and also want access to the raw HTTP body.\n\nExample:\n\n    message GetResourceRequest {\n      // A unique request id.\n      string request_id = 1;\n\n      // The raw HTTP body is bound to this field.\n      google.api.HttpBody http_body = 2;\n\n    }\n\n    service ResourceService {\n      rpc GetResource(GetResourceRequest)\n        returns (google.api.HttpBody);\n      rpc UpdateResource(google.api.HttpBody)\n        returns (google.protobuf.Empty);\n\n    }\n\nExample with streaming methods:\n\n    service CaldavService {\n      rpc GetCalendar(stream google.api.HttpBody)\n        returns (stream google.api.HttpBody);\n      rpc UpdateCalendar(stream google.api.HttpBody)\n        returns (stream google.api.HttpBody);\n\n    }\n\nUse of this type only changes how the request and response bodies are\nhandled, all other features will continue to work unchanged."
     },
+    "evening_detective_serverAddScenarioPlaceReq": {
+      "type": "object",
+      "properties": {
+        "place": {
+          "$ref": "#/definitions/evening_detective_serverPlace"
+        }
+      }
+    },
+    "evening_detective_serverAddScenarioPlaceRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        }
+      }
+    },
+    "evening_detective_serverAddScenarioReq": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      }
+    },
+    "evening_detective_serverAddScenarioRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        },
+        "id": {
+          "type": "integer",
+          "format": "int32"
+        }
+      }
+    },
     "evening_detective_serverAddUserRoleRsp": {
       "type": "object",
       "properties": {
@@ -526,6 +841,33 @@
         }
       }
     },
+    "evening_detective_serverApplication": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "image": {
+          "type": "string"
+        }
+      }
+    },
+    "evening_detective_serverDeleteScenarioPlaceRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        }
+      }
+    },
+    "evening_detective_serverDeleteScenarioRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        }
+      }
+    },
     "evening_detective_serverDeleteUserRoleRsp": {
       "type": "object",
       "properties": {
@@ -534,6 +876,24 @@
         }
       }
     },
+    "evening_detective_serverDoor": {
+      "type": "object",
+      "properties": {
+        "code": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "keys": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/evening_detective_serverKey"
+          }
+        }
+      }
+    },
     "evening_detective_serverEchoRsp": {
       "type": "object",
       "properties": {
@@ -553,6 +913,21 @@
         }
       }
     },
+    "evening_detective_serverGetMyScenariosRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        },
+        "scenarios": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/evening_detective_serverScenario"
+          }
+        }
+      }
+    },
     "evening_detective_serverGetPermissionsRsp": {
       "type": "object",
       "properties": {
@@ -567,6 +942,17 @@
         }
       }
     },
+    "evening_detective_serverGetScenarioRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        },
+        "scenario": {
+          "$ref": "#/definitions/evening_detective_serverScenario"
+        }
+      }
+    },
     "evening_detective_serverGetUserByIdRsp": {
       "type": "object",
       "properties": {
@@ -593,6 +979,14 @@
         }
       }
     },
+    "evening_detective_serverKey": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        }
+      }
+    },
     "evening_detective_serverLoginReq": {
       "type": "object",
       "properties": {
@@ -621,6 +1015,47 @@
     "evening_detective_serverPingRsp": {
       "type": "object"
     },
+    "evening_detective_serverPlace": {
+      "type": "object",
+      "properties": {
+        "code": {
+          "type": "string"
+        },
+        "name": {
+          "type": "string"
+        },
+        "text": {
+          "type": "string"
+        },
+        "image": {
+          "type": "string"
+        },
+        "hidden": {
+          "type": "boolean"
+        },
+        "applications": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/evening_detective_serverApplication"
+          }
+        },
+        "doors": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/evening_detective_serverDoor"
+          }
+        },
+        "keys": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/evening_detective_serverKey"
+          }
+        }
+      }
+    },
     "evening_detective_serverRefreshPasswordReq": {
       "type": "object",
       "properties": {
@@ -659,6 +1094,42 @@
         }
       }
     },
+    "evening_detective_serverScenario": {
+      "type": "object",
+      "properties": {
+        "id": {
+          "type": "integer",
+          "format": "int32"
+        },
+        "name": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "image": {
+          "type": "string"
+        },
+        "story": {
+          "$ref": "#/definitions/evening_detective_serverStory"
+        },
+        "author": {
+          "$ref": "#/definitions/evening_detective_serverUser"
+        },
+        "updatedAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "createdAt": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "publishedAt": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
     "evening_detective_serverSignupReq": {
       "type": "object",
       "properties": {
@@ -678,6 +1149,34 @@
         }
       }
     },
+    "evening_detective_serverStory": {
+      "type": "object",
+      "properties": {
+        "places": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "$ref": "#/definitions/evening_detective_serverPlace"
+          }
+        }
+      }
+    },
+    "evening_detective_serverUpdateScenarioPlaceRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        }
+      }
+    },
+    "evening_detective_serverUpdateScenarioRsp": {
+      "type": "object",
+      "properties": {
+        "error": {
+          "type": "string"
+        }
+      }
+    },
     "evening_detective_serverUploadFileReq": {
       "type": "object",
       "properties": {

internal/app/server.go

@@ -6,6 +6,7 @@ import (
 	"evening_detective_server/internal/modules/processor_jwt"
 	"evening_detective_server/internal/modules/roles"
 	"evening_detective_server/internal/services/file_service"
+	"evening_detective_server/internal/services/scenarios_service"
 	"evening_detective_server/internal/services/ui_service"
 	"evening_detective_server/internal/services/users_service"
 	proto "evening_detective_server/proto"
@@ -21,17 +22,20 @@ type server struct {
 	usersService    *users_service.UsersService
 	uiService       *ui_service.UiService
 	fileService     *file_service.FileService
+	scenarioService *scenarios_service.ScenarioService
 }
 
 func NewServer(
 	usersService *users_service.UsersService,
 	uiService *ui_service.UiService,
 	fileService *file_service.FileService,
+	scenarioService *scenarios_service.ScenarioService,
 ) proto.EveningDetectiveServerServer {
 	return &server{
 		usersService:    usersService,
 		uiService:       uiService,
 		fileService:     fileService,
+		scenarioService: scenarioService,
 	}
 }
 
@@ -202,3 +206,124 @@ func (s *server) DownloadFile(ctx context.Context, req *proto.DownloadFileReq) (
 		ContentType: file.Mime,
 	}, nil
 }
+
+func (s *server) AddScenario(ctx context.Context, req *proto.AddScenarioReq) (*proto.AddScenarioRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	id, err := s.scenarioService.AddScenario(ctx, req.Name, claims.UserID)
+	if err != nil {
+		return &proto.AddScenarioRsp{
+			Error: err.Error(),
+		}, nil
+	}
+	return &proto.AddScenarioRsp{
+		Id: int32(id),
+	}, nil
+}
+
+func (s *server) GetMyScenarios(ctx context.Context, req *proto.GetMyScenariosReq) (*proto.GetMyScenariosRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	scenarios, err := s.scenarioService.GetScenariosByAuthorID(ctx, claims.UserID)
+	if err != nil {
+		return &proto.GetMyScenariosRsp{
+			Error: err.Error(),
+		}, nil
+	}
+
+	return &proto.GetMyScenariosRsp{
+		Scenarios: mapScenarios(scenarios),
+	}, nil
+}
+
+func (s *server) GetScenario(ctx context.Context, req *proto.GetScenarioReq) (*proto.GetScenarioRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	scenario, err := s.scenarioService.GetScenarioByID(ctx, int(req.Id))
+	if err != nil {
+		return &proto.GetScenarioRsp{
+			Error: err.Error(),
+		}, nil
+	}
+
+	return &proto.GetScenarioRsp{
+		Scenario: mapScenario(scenario),
+	}, nil
+}
+
+func (s *server) UpdateScenario(ctx context.Context, req *proto.UpdateScenarioReq) (*proto.UpdateScenarioRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	err := s.scenarioService.UpdateScenarioByID(
+		ctx,
+		int(req.Id),
+		req.Name,
+		req.Description,
+		req.Image,
+	)
+	if err != nil {
+		return &proto.UpdateScenarioRsp{
+			Error: err.Error(),
+		}, nil
+	}
+
+	return &proto.UpdateScenarioRsp{}, nil
+}
+
+func (s *server) DeleteScenario(ctx context.Context, req *proto.DeleteScenarioReq) (*proto.DeleteScenarioRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	err := s.scenarioService.DeleteScenarioByID(
+		ctx,
+		int(req.Id),
+	)
+	if err != nil {
+		return &proto.DeleteScenarioRsp{
+			Error: err.Error(),
+		}, nil
+	}
+
+	return &proto.DeleteScenarioRsp{}, nil
+}
+
+func (s *server) AddScenarioPlace(ctx context.Context, req *proto.AddScenarioPlaceReq) (*proto.AddScenarioPlaceRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	panic("unimplemented")
+}
+
+func (s *server) UpdateScenarioPlace(ctx context.Context, req *proto.UpdateScenarioPlaceReq) (*proto.UpdateScenarioPlaceRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	panic("unimplemented")
+}
+
+func (s *server) DeleteScenarioPlace(ctx context.Context, req *proto.DeleteScenarioPlaceReq) (*proto.DeleteScenarioPlaceRsp, error) {
+	claims := ctx.Value("claims").(*processor_jwt.JWTClaims)
+	if !roles.HasRole(claims, roles.Author) {
+		return nil, status.Errorf(codes.PermissionDenied, "permission denied")
+	}
+
+	panic("unimplemented")
+}

internal/app/story_mapper.go

@@ -0,0 +1,107 @@
+package app
+
+import (
+	"evening_detective_server/internal/modules/storytelling"
+	"evening_detective_server/internal/services/scenarios_service"
+	proto "evening_detective_server/proto"
+
+	"google.golang.org/protobuf/types/known/timestamppb"
+)
+
+func mapScenarios(o []*scenarios_service.Scenario) []*proto.Scenario {
+	res := make([]*proto.Scenario, 0, len(o))
+	for _, item := range o {
+		res = append(res, mapScenario(item))
+	}
+	return res
+}
+
+func mapScenario(o *scenarios_service.Scenario) *proto.Scenario {
+	var publishedAt *timestamppb.Timestamp
+	if o.PublishedAt != nil {
+		publishedAt = timestamppb.New(*o.PublishedAt)
+	}
+	return &proto.Scenario{
+		Id:          int32(o.ID),
+		Name:        o.Name,
+		Description: o.Description,
+		Image:       o.Image,
+		Story:       mapStory(o.Story),
+		Author:      mapUser(o.Author),
+		UpdatedAt:   timestamppb.New(o.UpdatedAt),
+		CreatedAt:   timestamppb.New(o.CreatedAt),
+		PublishedAt: publishedAt,
+	}
+}
+
+func mapStory(o *storytelling.Story) *proto.Story {
+	return &proto.Story{
+		Places: mapPlaces(o.Places),
+	}
+}
+
+func mapPlaces(o []*storytelling.Place) []*proto.Place {
+	res := make([]*proto.Place, 0, len(o))
+	for _, item := range o {
+		res = append(res, mapPlace(item))
+	}
+	return res
+}
+
+func mapPlace(o *storytelling.Place) *proto.Place {
+	return &proto.Place{
+		Code:         o.Code,
+		Name:         o.Name,
+		Text:         o.Text,
+		Image:        o.Image,
+		Hidden:       o.Hidden,
+		Applications: mapApplications(o.Applications),
+		Doors:        mapDoors(o.Doors),
+		Keys:         mapKeys(o.Keys),
+	}
+}
+
+func mapApplications(o []*storytelling.Application) []*proto.Application {
+	res := make([]*proto.Application, 0, len(o))
+	for _, item := range o {
+		res = append(res, mapApplication(item))
+	}
+	return res
+}
+
+func mapDoors(o []*storytelling.Door) []*proto.Door {
+	res := make([]*proto.Door, 0, len(o))
+	for _, item := range o {
+		res = append(res, mapDoor(item))
+	}
+	return res
+}
+
+func mapKeys(o []*storytelling.Key) []*proto.Key {
+	res := make([]*proto.Key, 0, len(o))
+	for _, item := range o {
+		res = append(res, mapKey(item))
+	}
+	return res
+}
+
+func mapApplication(o *storytelling.Application) *proto.Application {
+	return &proto.Application{
+		Name:  o.Name,
+		Image: o.Image,
+	}
+}
+
+func mapDoor(o *storytelling.Door) *proto.Door {
+	return &proto.Door{
+		Code: o.Code,
+		Name: o.Name,
+		Keys: mapKeys(o.Keys),
+	}
+}
+
+func mapKey(o *storytelling.Key) *proto.Key {
+	return &proto.Key{
+		Name: o.Name,
+	}
+}

internal/repos/scenario.go

@@ -0,0 +1,17 @@
+package repos
+
+import "time"
+
+type Scenario struct {
+	ID          int
+	Name        string
+	Description *string
+	Image       *string
+	Scenario    string
+	Author      *User
+	Status      string
+	UpdatedAt   time.Time
+	CreatedAt   time.Time
+	PublishedAt *time.Time
+	IsDeleted   bool
+}

internal/repos/scenarios_repo/repo.go

@@ -0,0 +1,206 @@
+package scenarios_repo
+
+import (
+	"context"
+	"errors"
+	"evening_detective_server/internal/repos"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/pgxpool"
+)
+
+var (
+	ErrScenarioNotFound = errors.New("Сценарий не найден")
+)
+
+type ScenariosRepo struct {
+	pool *pgxpool.Pool
+}
+
+func NewScenariosRepo(pool *pgxpool.Pool) *ScenariosRepo {
+	return &ScenariosRepo{
+		pool: pool,
+	}
+}
+
+func (s *ScenariosRepo) AddScenario(
+	ctx context.Context,
+	name string,
+	authorId int,
+) (int, error) {
+	id := 0
+	err := s.pool.QueryRow(
+		ctx,
+		`INSERT INTO scenarios (name, author_id)
+		VALUES ($1, $2)
+		RETURNING id`,
+		name,
+		authorId,
+	).Scan(&id)
+
+	if err != nil {
+		return 0, err
+	}
+	return id, nil
+}
+
+func (s *ScenariosRepo) GetScenariosByAuthorID(
+	ctx context.Context,
+	authorId int,
+) ([]*repos.Scenario, error) {
+	rows, err := s.pool.Query(
+		ctx,
+		`SELECT 
+			scenarios.id, 
+			scenarios.name, 
+			scenarios.description, 
+			scenarios.image, 
+			scenarios.scenario, 
+			users.id, 
+			users.username, 
+			scenarios.status, 
+			scenarios.updated_at, 
+			scenarios.created_at, 
+			scenarios.published_at
+		FROM scenarios
+		LEFT JOIN users on scenarios.author_id = users.id
+		WHERE scenarios.author_id = $1 and is_deleted = FALSE
+		ORDER BY created_at DESC`,
+		authorId,
+	)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var scenarios []*repos.Scenario
+	for rows.Next() {
+		scenario := &repos.Scenario{
+			Author: &repos.User{},
+		}
+		err := rows.Scan(
+			&scenario.ID,
+			&scenario.Name,
+			&scenario.Description,
+			&scenario.Image,
+			&scenario.Scenario,
+			&scenario.Author.ID,
+			&scenario.Author.Username,
+			&scenario.Status,
+			&scenario.UpdatedAt,
+			&scenario.CreatedAt,
+			&scenario.PublishedAt,
+		)
+		if err != nil {
+			return nil, err
+		}
+		scenarios = append(scenarios, scenario)
+	}
+	if err := rows.Err(); err != nil {
+		return nil, err
+	}
+
+	return scenarios, nil
+}
+
+func (s *ScenariosRepo) GetScenarioByID(
+	ctx context.Context,
+	id int,
+) (*repos.Scenario, error) {
+	scenario := &repos.Scenario{
+		Author: &repos.User{},
+	}
+	row := s.pool.QueryRow(
+		ctx,
+		`SELECT 
+			scenarios.id, 
+			scenarios.name, 
+			scenarios.description, 
+			scenarios.image, 
+			scenarios.scenario, 
+			users.id, 
+			users.username, 
+			scenarios.status, 
+			scenarios.updated_at, 
+			scenarios.created_at, 
+			scenarios.published_at, 
+			scenarios.is_deleted
+		FROM scenarios
+		LEFT JOIN users on scenarios.author_id = users.id
+		WHERE scenarios.id = $1`,
+		id,
+	)
+	err := row.Scan(
+		&scenario.ID,
+		&scenario.Name,
+		&scenario.Description,
+		&scenario.Image,
+		&scenario.Scenario,
+		&scenario.Author.ID,
+		&scenario.Author.Username,
+		&scenario.Status,
+		&scenario.UpdatedAt,
+		&scenario.CreatedAt,
+		&scenario.PublishedAt,
+		&scenario.IsDeleted,
+	)
+	if err != nil {
+		if errors.Is(err, pgx.ErrNoRows) {
+			return nil, ErrScenarioNotFound
+		}
+		return nil, err
+	}
+
+	return scenario, nil
+}
+
+func (s *ScenariosRepo) UpdateScenarioByID(
+	ctx context.Context,
+	id int,
+	name string,
+	description string,
+	image string,
+) error {
+	tag, err := s.pool.Exec(
+		ctx,
+		`UPDATE scenarios
+		SET 
+			name = $1,
+			description = $2,
+			image = $3,
+			updated_at = NOW()
+		WHERE id = $4`,
+		name,
+		description,
+		image,
+		id,
+	)
+	if err != nil {
+		return err
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrScenarioNotFound
+	}
+	return nil
+}
+
+func (s *ScenariosRepo) DeleteScenarioByID(
+	ctx context.Context,
+	id int,
+) error {
+	tag, err := s.pool.Exec(
+		ctx,
+		`UPDATE scenarios
+		SET 
+			is_deleted = TRUE
+		WHERE id = $1`,
+		id,
+	)
+	if err != nil {
+		return err
+	}
+	if tag.RowsAffected() == 0 {
+		return ErrScenarioNotFound
+	}
+	return nil
+}

internal/repos/users_repo/repo.go

@@ -169,7 +169,6 @@ func (s *UsersRepo) GetUsers(
 		}
 		users = append(users, user)
 	}
-
 	if err := rows.Err(); err != nil {
 		return nil, err
 	}

internal/services/scenarios_service/scenario.go

@@ -0,0 +1,21 @@
+package scenarios_service
+
+import (
+	"evening_detective_server/internal/modules/storytelling"
+	"evening_detective_server/internal/repos"
+	"time"
+)
+
+type Scenario struct {
+	ID          int
+	Name        string
+	Description *string
+	Image       *string
+	Story       *storytelling.Story
+	Author      *repos.User
+	Status      string
+	UpdatedAt   time.Time
+	CreatedAt   time.Time
+	PublishedAt *time.Time
+	IsDeleted   bool
+}

internal/services/scenarios_service/scenario_mapper.go

@@ -0,0 +1,39 @@
+package scenarios_service
+
+import (
+	"encoding/json"
+	"evening_detective_server/internal/modules/storytelling"
+	"evening_detective_server/internal/repos"
+)
+
+func mapScenarios(o []*repos.Scenario) ([]*Scenario, error) {
+	res := make([]*Scenario, 0, len(o))
+	for _, item := range o {
+		scenario, err := mapScenario(item)
+		if err != nil {
+			return nil, err
+		}
+		res = append(res, scenario)
+	}
+	return res, nil
+}
+
+func mapScenario(o *repos.Scenario) (*Scenario, error) {
+	story := &storytelling.Story{}
+	if err := json.Unmarshal([]byte(o.Scenario), story); err != nil {
+		return nil, err
+	}
+	return &Scenario{
+		ID:          o.ID,
+		Name:        o.Name,
+		Description: o.Description,
+		Image:       o.Image,
+		Story:       story,
+		Author:      o.Author,
+		Status:      o.Status,
+		UpdatedAt:   o.UpdatedAt,
+		CreatedAt:   o.CreatedAt,
+		PublishedAt: o.PublishedAt,
+		IsDeleted:   o.IsDeleted,
+	}, nil
+}

internal/services/scenarios_service/service.go

@@ -0,0 +1,69 @@
+package scenarios_service
+
+import (
+	"context"
+	"evening_detective_server/internal/repos/scenarios_repo"
+)
+
+type ScenarioService struct {
+	scenariosRepo *scenarios_repo.ScenariosRepo
+}
+
+func NewScenarioService(
+	scenariosRepo *scenarios_repo.ScenariosRepo,
+) *ScenarioService {
+	return &ScenarioService{
+		scenariosRepo: scenariosRepo,
+	}
+}
+
+func (s *ScenarioService) AddScenario(
+	ctx context.Context,
+	name string,
+	authorId int,
+) (int, error) {
+	id, err := s.scenariosRepo.AddScenario(ctx, name, authorId)
+	if err != nil {
+		return 0, err
+	}
+	return id, nil
+}
+
+func (s *ScenarioService) GetScenariosByAuthorID(
+	ctx context.Context,
+	authorId int,
+) ([]*Scenario, error) {
+	scenarios, err := s.scenariosRepo.GetScenariosByAuthorID(ctx, authorId)
+	if err != nil {
+		return nil, err
+	}
+	return mapScenarios(scenarios)
+}
+
+func (s *ScenarioService) GetScenarioByID(
+	ctx context.Context,
+	id int,
+) (*Scenario, error) {
+	scenario, err := s.scenariosRepo.GetScenarioByID(ctx, id)
+	if err != nil {
+		return nil, err
+	}
+	return mapScenario(scenario)
+}
+
+func (s *ScenarioService) UpdateScenarioByID(
+	ctx context.Context,
+	id int,
+	name string,
+	description string,
+	image string,
+) error {
+	return s.scenariosRepo.UpdateScenarioByID(ctx, id, name, description, image)
+}
+
+func (s *ScenarioService) DeleteScenarioByID(
+	ctx context.Context,
+	id int,
+) error {
+	return s.scenariosRepo.DeleteScenarioByID(ctx, id)
+}

migrations/20260628175120_create_users_table.sql

@@ -5,7 +5,7 @@ CREATE TABLE
         username VARCHAR(50) NOT NULL UNIQUE,
         email VARCHAR(100) NOT NULL UNIQUE,
         password_hash VARCHAR(255) NOT NULL,
-        roles jsonb NOT NULL DEFAULT '[]'::jsonb,
+        roles JSONB NOT NULL DEFAULT '[]'::jsonb,
         is_active BOOLEAN DEFAULT TRUE,
         created_at TIMESTAMP NOT NULL DEFAULT NOW ()
     );

migrations/20260704192907_refresh_tokens_table.sql

@@ -6,6 +6,7 @@ CREATE TABLE
         expires_at TIMESTAMP NOT NULL,
         jti VARCHAR(255) NOT NULL UNIQUE,
         created_at TIMESTAMP NOT NULL DEFAULT NOW (),
+        
         CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES users (id) ON DELETE CASCADE
     );
 

migrations/20260712154823_create_scenarios_table.sql

@@ -0,0 +1,20 @@
+-- +goose Up
+CREATE TABLE
+    IF NOT EXISTS scenarios (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255) NOT NULL UNIQUE,
+        description TEXT,
+        image TEXT,
+        scenario JSONB NOT NULL DEFAULT '{}'::jsonb,
+        author_id INTEGER NOT NULL,
+        status VARCHAR(50) DEFAULT 'draft',
+        updated_at TIMESTAMP NOT NULL DEFAULT NOW (),
+        created_at TIMESTAMP NOT NULL DEFAULT NOW (),
+        published_at TIMESTAMP,
+        is_deleted BOOLEAN DEFAULT FALSE,
+
+        CONSTRAINT fk_scenarios_author FOREIGN KEY (author_id) REFERENCES users (id) ON DELETE RESTRICT
+    );
+
+-- +goose Down
+DROP TABLE IF EXISTS scenarios;

proto/main.pb.gw.go

@@ -457,6 +457,288 @@ func local_request_EveningDetectiveServer_DownloadFile_0(ctx context.Context, ma
 	return msg, metadata, err
 }
 
+func request_EveningDetectiveServer_AddScenario_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq AddScenarioReq
+		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.AddScenario(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_AddScenario_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq AddScenarioReq
+		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.AddScenario(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_EveningDetectiveServer_GetMyScenarios_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq GetMyScenariosReq
+		metadata runtime.ServerMetadata
+	)
+	if req.Body != nil {
+		_, _ = io.Copy(io.Discard, req.Body)
+	}
+	msg, err := client.GetMyScenarios(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_GetMyScenarios_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq GetMyScenariosReq
+		metadata runtime.ServerMetadata
+	)
+	msg, err := server.GetMyScenarios(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_EveningDetectiveServer_GetScenario_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq GetScenarioReq
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	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.GetScenario(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_GetScenario_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq GetScenarioReq
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	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.GetScenario(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_EveningDetectiveServer_UpdateScenario_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq UpdateScenarioReq
+		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.UpdateScenario(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_UpdateScenario_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq UpdateScenarioReq
+		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.UpdateScenario(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_EveningDetectiveServer_DeleteScenario_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq DeleteScenarioReq
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	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.DeleteScenario(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_DeleteScenario_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq DeleteScenarioReq
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	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.DeleteScenario(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_EveningDetectiveServer_AddScenarioPlace_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq AddScenarioPlaceReq
+		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.AddScenarioPlace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_AddScenarioPlace_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq AddScenarioPlaceReq
+		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.AddScenarioPlace(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_EveningDetectiveServer_UpdateScenarioPlace_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq UpdateScenarioPlaceReq
+		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["code"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "code")
+	}
+	protoReq.Code, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code", err)
+	}
+	msg, err := client.UpdateScenarioPlace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_UpdateScenarioPlace_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq UpdateScenarioPlaceReq
+		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["code"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "code")
+	}
+	protoReq.Code, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code", err)
+	}
+	msg, err := server.UpdateScenarioPlace(ctx, &protoReq)
+	return msg, metadata, err
+}
+
+func request_EveningDetectiveServer_DeleteScenarioPlace_0(ctx context.Context, marshaler runtime.Marshaler, client EveningDetectiveServerClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq DeleteScenarioPlaceReq
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	if req.Body != nil {
+		_, _ = io.Copy(io.Discard, req.Body)
+	}
+	val, ok := pathParams["code"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "code")
+	}
+	protoReq.Code, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code", err)
+	}
+	msg, err := client.DeleteScenarioPlace(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+	return msg, metadata, err
+}
+
+func local_request_EveningDetectiveServer_DeleteScenarioPlace_0(ctx context.Context, marshaler runtime.Marshaler, server EveningDetectiveServerServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+	var (
+		protoReq DeleteScenarioPlaceReq
+		metadata runtime.ServerMetadata
+		err      error
+	)
+	val, ok := pathParams["code"]
+	if !ok {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "code")
+	}
+	protoReq.Code, err = runtime.String(val)
+	if err != nil {
+		return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "code", err)
+	}
+	msg, err := server.DeleteScenarioPlace(ctx, &protoReq)
+	return msg, metadata, err
+}
+
 // RegisterEveningDetectiveServerHandlerServer registers the http handlers for service EveningDetectiveServer to "mux".
 // UnaryRPC     :call EveningDetectiveServerServer directly.
 // StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
@@ -743,6 +1025,166 @@ func RegisterEveningDetectiveServerHandlerServer(ctx context.Context, mux *runti
 		}
 		forward_EveningDetectiveServer_DownloadFile_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
+	mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_AddScenario_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/AddScenario", runtime.WithHTTPPathPattern("/api/scenario"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_AddScenario_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_AddScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetMyScenarios_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/GetMyScenarios", runtime.WithHTTPPathPattern("/api/my-scenarios"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_GetMyScenarios_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_GetMyScenarios_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetScenario_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/GetScenario", runtime.WithHTTPPathPattern("/api/scenarios/{id}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_GetScenario_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_GetScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPut, pattern_EveningDetectiveServer_UpdateScenario_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/UpdateScenario", runtime.WithHTTPPathPattern("/api/scenarios/{id}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_UpdateScenario_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_UpdateScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodDelete, pattern_EveningDetectiveServer_DeleteScenario_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/DeleteScenario", runtime.WithHTTPPathPattern("/api/scenarios/{id}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_DeleteScenario_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_DeleteScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_AddScenarioPlace_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/AddScenarioPlace", runtime.WithHTTPPathPattern("/api/scenarios/places"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_AddScenarioPlace_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_AddScenarioPlace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPut, pattern_EveningDetectiveServer_UpdateScenarioPlace_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/UpdateScenarioPlace", runtime.WithHTTPPathPattern("/api/scenarios/places/{code}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_UpdateScenarioPlace_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_UpdateScenarioPlace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodDelete, pattern_EveningDetectiveServer_DeleteScenarioPlace_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/DeleteScenarioPlace", runtime.WithHTTPPathPattern("/api/scenarios/places/{code}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := local_request_EveningDetectiveServer_DeleteScenarioPlace_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_DeleteScenarioPlace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
 
 	return nil
 }
@@ -1021,6 +1463,142 @@ func RegisterEveningDetectiveServerHandlerClient(ctx context.Context, mux *runti
 		}
 		forward_EveningDetectiveServer_DownloadFile_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
 	})
+	mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_AddScenario_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/AddScenario", runtime.WithHTTPPathPattern("/api/scenario"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_AddScenario_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_AddScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetMyScenarios_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/GetMyScenarios", runtime.WithHTTPPathPattern("/api/my-scenarios"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_GetMyScenarios_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_GetMyScenarios_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodGet, pattern_EveningDetectiveServer_GetScenario_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/GetScenario", runtime.WithHTTPPathPattern("/api/scenarios/{id}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_GetScenario_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_GetScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPut, pattern_EveningDetectiveServer_UpdateScenario_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/UpdateScenario", runtime.WithHTTPPathPattern("/api/scenarios/{id}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_UpdateScenario_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_UpdateScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodDelete, pattern_EveningDetectiveServer_DeleteScenario_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/DeleteScenario", runtime.WithHTTPPathPattern("/api/scenarios/{id}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_DeleteScenario_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_DeleteScenario_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPost, pattern_EveningDetectiveServer_AddScenarioPlace_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/AddScenarioPlace", runtime.WithHTTPPathPattern("/api/scenarios/places"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_AddScenarioPlace_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_AddScenarioPlace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodPut, pattern_EveningDetectiveServer_UpdateScenarioPlace_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/UpdateScenarioPlace", runtime.WithHTTPPathPattern("/api/scenarios/places/{code}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_UpdateScenarioPlace_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_UpdateScenarioPlace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
+	mux.Handle(http.MethodDelete, pattern_EveningDetectiveServer_DeleteScenarioPlace_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/DeleteScenarioPlace", runtime.WithHTTPPathPattern("/api/scenarios/places/{code}"))
+		if err != nil {
+			runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+			return
+		}
+		resp, md, err := request_EveningDetectiveServer_DeleteScenarioPlace_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_DeleteScenarioPlace_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+	})
 	return nil
 }
 
@@ -1039,6 +1617,14 @@ var (
 	pattern_EveningDetectiveServer_GetPermissions_0      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "ui", "permissions"}, ""))
 	pattern_EveningDetectiveServer_UploadFile_0          = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "files", "upload"}, ""))
 	pattern_EveningDetectiveServer_DownloadFile_0        = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"api", "files", "filename"}, ""))
+	pattern_EveningDetectiveServer_AddScenario_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"api", "scenario"}, ""))
+	pattern_EveningDetectiveServer_GetMyScenarios_0      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"api", "my-scenarios"}, ""))
+	pattern_EveningDetectiveServer_GetScenario_0         = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"api", "scenarios", "id"}, ""))
+	pattern_EveningDetectiveServer_UpdateScenario_0      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"api", "scenarios", "id"}, ""))
+	pattern_EveningDetectiveServer_DeleteScenario_0      = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2}, []string{"api", "scenarios", "id"}, ""))
+	pattern_EveningDetectiveServer_AddScenarioPlace_0    = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"api", "scenarios", "places"}, ""))
+	pattern_EveningDetectiveServer_UpdateScenarioPlace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "scenarios", "places", "code"}, ""))
+	pattern_EveningDetectiveServer_DeleteScenarioPlace_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"api", "scenarios", "places", "code"}, ""))
 )
 
 var (
@@ -1056,4 +1642,12 @@ var (
 	forward_EveningDetectiveServer_GetPermissions_0      = runtime.ForwardResponseMessage
 	forward_EveningDetectiveServer_UploadFile_0          = runtime.ForwardResponseMessage
 	forward_EveningDetectiveServer_DownloadFile_0        = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_AddScenario_0         = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_GetMyScenarios_0      = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_GetScenario_0         = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_UpdateScenario_0      = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_DeleteScenario_0      = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_AddScenarioPlace_0    = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_UpdateScenarioPlace_0 = runtime.ForwardResponseMessage
+	forward_EveningDetectiveServer_DeleteScenarioPlace_0 = runtime.ForwardResponseMessage
 )

proto/main_grpc.pb.go

@@ -34,6 +34,14 @@ const (
 	EveningDetectiveServer_GetPermissions_FullMethodName      = "/crabs.evening_detective_server.EveningDetectiveServer/GetPermissions"
 	EveningDetectiveServer_UploadFile_FullMethodName          = "/crabs.evening_detective_server.EveningDetectiveServer/UploadFile"
 	EveningDetectiveServer_DownloadFile_FullMethodName        = "/crabs.evening_detective_server.EveningDetectiveServer/DownloadFile"
+	EveningDetectiveServer_AddScenario_FullMethodName         = "/crabs.evening_detective_server.EveningDetectiveServer/AddScenario"
+	EveningDetectiveServer_GetMyScenarios_FullMethodName      = "/crabs.evening_detective_server.EveningDetectiveServer/GetMyScenarios"
+	EveningDetectiveServer_GetScenario_FullMethodName         = "/crabs.evening_detective_server.EveningDetectiveServer/GetScenario"
+	EveningDetectiveServer_UpdateScenario_FullMethodName      = "/crabs.evening_detective_server.EveningDetectiveServer/UpdateScenario"
+	EveningDetectiveServer_DeleteScenario_FullMethodName      = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteScenario"
+	EveningDetectiveServer_AddScenarioPlace_FullMethodName    = "/crabs.evening_detective_server.EveningDetectiveServer/AddScenarioPlace"
+	EveningDetectiveServer_UpdateScenarioPlace_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/UpdateScenarioPlace"
+	EveningDetectiveServer_DeleteScenarioPlace_FullMethodName = "/crabs.evening_detective_server.EveningDetectiveServer/DeleteScenarioPlace"
 )
 
 // EveningDetectiveServerClient is the client API for EveningDetectiveServer service.
@@ -54,6 +62,14 @@ type EveningDetectiveServerClient interface {
 	GetPermissions(ctx context.Context, in *GetPermissionsReq, opts ...grpc.CallOption) (*GetPermissionsRsp, error)
 	UploadFile(ctx context.Context, in *UploadFileReq, opts ...grpc.CallOption) (*UploadFileRsp, error)
 	DownloadFile(ctx context.Context, in *DownloadFileReq, opts ...grpc.CallOption) (*httpbody.HttpBody, error)
+	AddScenario(ctx context.Context, in *AddScenarioReq, opts ...grpc.CallOption) (*AddScenarioRsp, error)
+	GetMyScenarios(ctx context.Context, in *GetMyScenariosReq, opts ...grpc.CallOption) (*GetMyScenariosRsp, error)
+	GetScenario(ctx context.Context, in *GetScenarioReq, opts ...grpc.CallOption) (*GetScenarioRsp, error)
+	UpdateScenario(ctx context.Context, in *UpdateScenarioReq, opts ...grpc.CallOption) (*UpdateScenarioRsp, error)
+	DeleteScenario(ctx context.Context, in *DeleteScenarioReq, opts ...grpc.CallOption) (*DeleteScenarioRsp, error)
+	AddScenarioPlace(ctx context.Context, in *AddScenarioPlaceReq, opts ...grpc.CallOption) (*AddScenarioPlaceRsp, error)
+	UpdateScenarioPlace(ctx context.Context, in *UpdateScenarioPlaceReq, opts ...grpc.CallOption) (*UpdateScenarioPlaceRsp, error)
+	DeleteScenarioPlace(ctx context.Context, in *DeleteScenarioPlaceReq, opts ...grpc.CallOption) (*DeleteScenarioPlaceRsp, error)
 }
 
 type eveningDetectiveServerClient struct {
@@ -204,6 +220,86 @@ func (c *eveningDetectiveServerClient) DownloadFile(ctx context.Context, in *Dow
 	return out, nil
 }
 
+func (c *eveningDetectiveServerClient) AddScenario(ctx context.Context, in *AddScenarioReq, opts ...grpc.CallOption) (*AddScenarioRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(AddScenarioRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_AddScenario_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *eveningDetectiveServerClient) GetMyScenarios(ctx context.Context, in *GetMyScenariosReq, opts ...grpc.CallOption) (*GetMyScenariosRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(GetMyScenariosRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_GetMyScenarios_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *eveningDetectiveServerClient) GetScenario(ctx context.Context, in *GetScenarioReq, opts ...grpc.CallOption) (*GetScenarioRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(GetScenarioRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_GetScenario_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *eveningDetectiveServerClient) UpdateScenario(ctx context.Context, in *UpdateScenarioReq, opts ...grpc.CallOption) (*UpdateScenarioRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(UpdateScenarioRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_UpdateScenario_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *eveningDetectiveServerClient) DeleteScenario(ctx context.Context, in *DeleteScenarioReq, opts ...grpc.CallOption) (*DeleteScenarioRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(DeleteScenarioRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_DeleteScenario_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *eveningDetectiveServerClient) AddScenarioPlace(ctx context.Context, in *AddScenarioPlaceReq, opts ...grpc.CallOption) (*AddScenarioPlaceRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(AddScenarioPlaceRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_AddScenarioPlace_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *eveningDetectiveServerClient) UpdateScenarioPlace(ctx context.Context, in *UpdateScenarioPlaceReq, opts ...grpc.CallOption) (*UpdateScenarioPlaceRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(UpdateScenarioPlaceRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_UpdateScenarioPlace_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *eveningDetectiveServerClient) DeleteScenarioPlace(ctx context.Context, in *DeleteScenarioPlaceReq, opts ...grpc.CallOption) (*DeleteScenarioPlaceRsp, error) {
+	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
+	out := new(DeleteScenarioPlaceRsp)
+	err := c.cc.Invoke(ctx, EveningDetectiveServer_DeleteScenarioPlace_FullMethodName, in, out, cOpts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 // EveningDetectiveServerServer is the server API for EveningDetectiveServer service.
 // All implementations must embed UnimplementedEveningDetectiveServerServer
 // for forward compatibility.
@@ -222,6 +318,14 @@ type EveningDetectiveServerServer interface {
 	GetPermissions(context.Context, *GetPermissionsReq) (*GetPermissionsRsp, error)
 	UploadFile(context.Context, *UploadFileReq) (*UploadFileRsp, error)
 	DownloadFile(context.Context, *DownloadFileReq) (*httpbody.HttpBody, error)
+	AddScenario(context.Context, *AddScenarioReq) (*AddScenarioRsp, error)
+	GetMyScenarios(context.Context, *GetMyScenariosReq) (*GetMyScenariosRsp, error)
+	GetScenario(context.Context, *GetScenarioReq) (*GetScenarioRsp, error)
+	UpdateScenario(context.Context, *UpdateScenarioReq) (*UpdateScenarioRsp, error)
+	DeleteScenario(context.Context, *DeleteScenarioReq) (*DeleteScenarioRsp, error)
+	AddScenarioPlace(context.Context, *AddScenarioPlaceReq) (*AddScenarioPlaceRsp, error)
+	UpdateScenarioPlace(context.Context, *UpdateScenarioPlaceReq) (*UpdateScenarioPlaceRsp, error)
+	DeleteScenarioPlace(context.Context, *DeleteScenarioPlaceReq) (*DeleteScenarioPlaceRsp, error)
 	mustEmbedUnimplementedEveningDetectiveServerServer()
 }
 
@@ -274,6 +378,30 @@ func (UnimplementedEveningDetectiveServerServer) UploadFile(context.Context, *Up
 func (UnimplementedEveningDetectiveServerServer) DownloadFile(context.Context, *DownloadFileReq) (*httpbody.HttpBody, error) {
 	return nil, status.Error(codes.Unimplemented, "method DownloadFile not implemented")
 }
+func (UnimplementedEveningDetectiveServerServer) AddScenario(context.Context, *AddScenarioReq) (*AddScenarioRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method AddScenario not implemented")
+}
+func (UnimplementedEveningDetectiveServerServer) GetMyScenarios(context.Context, *GetMyScenariosReq) (*GetMyScenariosRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetMyScenarios not implemented")
+}
+func (UnimplementedEveningDetectiveServerServer) GetScenario(context.Context, *GetScenarioReq) (*GetScenarioRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method GetScenario not implemented")
+}
+func (UnimplementedEveningDetectiveServerServer) UpdateScenario(context.Context, *UpdateScenarioReq) (*UpdateScenarioRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method UpdateScenario not implemented")
+}
+func (UnimplementedEveningDetectiveServerServer) DeleteScenario(context.Context, *DeleteScenarioReq) (*DeleteScenarioRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method DeleteScenario not implemented")
+}
+func (UnimplementedEveningDetectiveServerServer) AddScenarioPlace(context.Context, *AddScenarioPlaceReq) (*AddScenarioPlaceRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method AddScenarioPlace not implemented")
+}
+func (UnimplementedEveningDetectiveServerServer) UpdateScenarioPlace(context.Context, *UpdateScenarioPlaceReq) (*UpdateScenarioPlaceRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method UpdateScenarioPlace not implemented")
+}
+func (UnimplementedEveningDetectiveServerServer) DeleteScenarioPlace(context.Context, *DeleteScenarioPlaceReq) (*DeleteScenarioPlaceRsp, error) {
+	return nil, status.Error(codes.Unimplemented, "method DeleteScenarioPlace not implemented")
+}
 func (UnimplementedEveningDetectiveServerServer) mustEmbedUnimplementedEveningDetectiveServerServer() {
 }
 func (UnimplementedEveningDetectiveServerServer) testEmbeddedByValue() {}
@@ -548,6 +676,150 @@ func _EveningDetectiveServer_DownloadFile_Handler(srv interface{}, ctx context.C
 	return interceptor(ctx, in, info, handler)
 }
 
+func _EveningDetectiveServer_AddScenario_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddScenarioReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).AddScenario(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_AddScenario_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).AddScenario(ctx, req.(*AddScenarioReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _EveningDetectiveServer_GetMyScenarios_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetMyScenariosReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).GetMyScenarios(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_GetMyScenarios_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).GetMyScenarios(ctx, req.(*GetMyScenariosReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _EveningDetectiveServer_GetScenario_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(GetScenarioReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).GetScenario(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_GetScenario_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).GetScenario(ctx, req.(*GetScenarioReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _EveningDetectiveServer_UpdateScenario_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateScenarioReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).UpdateScenario(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_UpdateScenario_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).UpdateScenario(ctx, req.(*UpdateScenarioReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _EveningDetectiveServer_DeleteScenario_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteScenarioReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).DeleteScenario(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_DeleteScenario_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).DeleteScenario(ctx, req.(*DeleteScenarioReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _EveningDetectiveServer_AddScenarioPlace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AddScenarioPlaceReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).AddScenarioPlace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_AddScenarioPlace_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).AddScenarioPlace(ctx, req.(*AddScenarioPlaceReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _EveningDetectiveServer_UpdateScenarioPlace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(UpdateScenarioPlaceReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).UpdateScenarioPlace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_UpdateScenarioPlace_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).UpdateScenarioPlace(ctx, req.(*UpdateScenarioPlaceReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _EveningDetectiveServer_DeleteScenarioPlace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteScenarioPlaceReq)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(EveningDetectiveServerServer).DeleteScenarioPlace(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: EveningDetectiveServer_DeleteScenarioPlace_FullMethodName,
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(EveningDetectiveServerServer).DeleteScenarioPlace(ctx, req.(*DeleteScenarioPlaceReq))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 // EveningDetectiveServer_ServiceDesc is the grpc.ServiceDesc for EveningDetectiveServer service.
 // It's only intended for direct use with grpc.RegisterService,
 // and not to be introspected or modified (even as a copy)
@@ -611,6 +883,38 @@ var EveningDetectiveServer_ServiceDesc = grpc.ServiceDesc{
 			MethodName: "DownloadFile",
 			Handler:    _EveningDetectiveServer_DownloadFile_Handler,
 		},
+		{
+			MethodName: "AddScenario",
+			Handler:    _EveningDetectiveServer_AddScenario_Handler,
+		},
+		{
+			MethodName: "GetMyScenarios",
+			Handler:    _EveningDetectiveServer_GetMyScenarios_Handler,
+		},
+		{
+			MethodName: "GetScenario",
+			Handler:    _EveningDetectiveServer_GetScenario_Handler,
+		},
+		{
+			MethodName: "UpdateScenario",
+			Handler:    _EveningDetectiveServer_UpdateScenario_Handler,
+		},
+		{
+			MethodName: "DeleteScenario",
+			Handler:    _EveningDetectiveServer_DeleteScenario_Handler,
+		},
+		{
+			MethodName: "AddScenarioPlace",
+			Handler:    _EveningDetectiveServer_AddScenarioPlace_Handler,
+		},
+		{
+			MethodName: "UpdateScenarioPlace",
+			Handler:    _EveningDetectiveServer_UpdateScenarioPlace_Handler,
+		},
+		{
+			MethodName: "DeleteScenarioPlace",
+			Handler:    _EveningDetectiveServer_DeleteScenarioPlace_Handler,
+		},
 	},
 	Streams:  []grpc.StreamDesc{},
 	Metadata: "main.proto",