XD (#100)

XD

MD

Co-authored-by: Michal Bohdanowicz <m.w.bohdanowicz@gmail.com>

.build/deploy.sh

@@ -1,9 +1,4 @@
 BUILD_PATH=$1
 
 cd $BUILD_PATH/src || exit 1
-
 docker build -f ./InternshipSystem.Api/Dockerfile -t internship.api .
-
-cd $BUILD_PATH/.docker || exit 1
-
-docker-compose up -d --build --force-recreate

PostmanTestRequest/StudentOperations.postman_collection.json

@@ -25,6 +25,193 @@
 			},
 			"response": []
 		},
+		{
+			"name": "GetInternshipManagementList",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjEwMjY2MzcxLCJleHAiOjE2MTAzNTI3NzEsImlhdCI6MTYxMDI2NjM3MX0.PDrMjCHJlpN2FApL6rC-UAoH1ZWAnUImwWfTDhvB5wI",
+							"type": "string"
+						}
+					]
+				},
+				"method": "GET",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"url": {
+					"raw": "http://localhost:8080/management/internship?OrderByField=InternshipState&SortOrder=Asc",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"internship"
+					],
+					"query": [
+						{
+							"key": "OrderByField",
+							"value": "InternshipState"
+						},
+						{
+							"key": "SortOrder",
+							"value": "Asc"
+						}
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "GetInternshipManagement",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjEwMjY2MzcxLCJleHAiOjE2MTAzNTI3NzEsImlhdCI6MTYxMDI2NjM3MX0.PDrMjCHJlpN2FApL6rC-UAoH1ZWAnUImwWfTDhvB5wI",
+							"type": "string"
+						}
+					]
+				},
+				"method": "GET",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"url": {
+					"raw": "http://localhost:8080/management/internship/1",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"internship",
+						"1"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "GetInternshipManagementAccept",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjEwMjY2MzcxLCJleHAiOjE2MTAzNTI3NzEsImlhdCI6MTYxMDI2NjM3MX0.PDrMjCHJlpN2FApL6rC-UAoH1ZWAnUImwWfTDhvB5wI",
+							"type": "string"
+						}
+					]
+				},
+				"method": "PUT",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "\"\""
+				},
+				"url": {
+					"raw": "http://localhost:8080/management/internship/accept/1",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"internship",
+						"accept",
+						"1"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "GetInternshipManagementReject",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjEwMjY2MzcxLCJleHAiOjE2MTAzNTI3NzEsImlhdCI6MTYxMDI2NjM3MX0.PDrMjCHJlpN2FApL6rC-UAoH1ZWAnUImwWfTDhvB5wI",
+							"type": "string"
+						}
+					]
+				},
+				"method": "PUT",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "\"Co żeś odrąbał andzeju\""
+				},
+				"url": {
+					"raw": "http://localhost:8080/management/internship/reject/1",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"internship",
+						"reject",
+						"1"
+					]
+				}
+			},
+			"response": []
+		},
 		{
 			"name": "loginEdition",
 			"request": {
@@ -91,14 +278,14 @@
 			"response": []
 		},
 		{
-			"name": "GetEditionManagementList",
+			"name": "GetCourseList",
 			"request": {
 				"auth": {
 					"type": "bearer",
 					"bearer": [
 						{
 							"key": "token",
-							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA0ODI3ODgzLCJleHAiOjE2MDQ5MTQyODMsImlhdCI6MTYwNDgyNzg4M30.a3mMm3Zk3xpfsmIwlqtpjgWgTNEXv8O4hH_V_L9UFZo",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
 							"type": "string"
 						}
 					]
@@ -117,14 +304,267 @@
 					}
 				],
 				"url": {
-					"raw": "http://localhost:8080/editionManagement",
+					"raw": "http://localhost:8080/management/course",
 					"protocol": "http",
 					"host": [
 						"localhost"
 					],
 					"port": "8080",
 					"path": [
-						"editionManagement"
+						"management",
+						"course"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "GetCourse",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
+							"type": "string"
+						}
+					]
+				},
+				"method": "GET",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"url": {
+					"raw": "http://localhost:8080/management/course/1",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"course",
+						"1"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "CreateCourse",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
+							"type": "string"
+						}
+					]
+				},
+				"method": "PUT",
+				"header": [
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "{\r\n  \"id\": null,\r\n  \"name\": \"testowy\",\r\n  \"nameEng\": \"test\"\r\n}"
+				},
+				"url": {
+					"raw": "http://localhost:8080/management/course",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"course"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "UpdateCourse",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
+							"type": "string"
+						}
+					]
+				},
+				"method": "PUT",
+				"header": [
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"body": {
+					"mode": "raw",
+					"raw": "{\r\n  \"id\": 3,\r\n  \"name\": \"testowyUp\",\r\n  \"nameEng\": \"testUp\"\r\n}"
+				},
+				"url": {
+					"raw": "http://localhost:8080/management/course",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"course"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "DeleteCourse",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
+							"type": "string"
+						}
+					]
+				},
+				"method": "DELETE",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"url": {
+					"raw": "http://localhost:8080/management/course/3",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"course",
+						"3"
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "GetEditionManagementListByCourse",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
+							"type": "string"
+						}
+					]
+				},
+				"method": "GET",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"url": {
+					"raw": "http://localhost:8080/management/editions?course=1",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"editions"
+					],
+					"query": [
+						{
+							"key": "course",
+							"value": "1"
+						}
+					]
+				}
+			},
+			"response": []
+		},
+		{
+			"name": "GetEditionManagementList",
+			"request": {
+				"auth": {
+					"type": "bearer",
+					"bearer": [
+						{
+							"key": "token",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
+							"type": "string"
+						}
+					]
+				},
+				"method": "GET",
+				"header": [
+					{
+						"key": "Authorization",
+						"type": "text",
+						"value": "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjAxMTk3NTYzLCJleHAiOjE2MDEyODM5NjMsImlhdCI6MTYwMTE5NzU2MywiRWRpdGlvbiI6IjEzOGRhOGEzLTg1NWMtNGIxNy05YmQyLTVmMzU3Njc5ZWZhOSJ9.l7QK1eUIJexnDaFKZ9yx3NWxmB2KrvPpjLUuuP1EJyE"
+					},
+					{
+						"key": "Content-Type",
+						"type": "text",
+						"value": "application/json"
+					}
+				],
+				"url": {
+					"raw": "http://localhost:8080/management/editions",
+					"protocol": "http",
+					"host": [
+						"localhost"
+					],
+					"port": "8080",
+					"path": [
+						"management",
+						"editions"
 					]
 				}
 			},
@@ -157,15 +597,16 @@
 					}
 				],
 				"url": {
-					"raw": "http://localhost:8080/editionManagement/bbc401c3-2d99-4142-bbb7-24c345d1fb21",
+					"raw": "http://localhost:8080/management/editions/138da8a3-855c-4b17-9bd2-5f357679efa9",
 					"protocol": "http",
 					"host": [
 						"localhost"
 					],
 					"port": "8080",
 					"path": [
-						"editionManagement",
+						"management",
-						"bbc401c3-2d99-4142-bbb7-24c345d1fb21"
+						"editions",
+						"138da8a3-855c-4b17-9bd2-5f357679efa9"
 					]
 				}
 			},
@@ -179,7 +620,7 @@
 					"bearer": [
 						{
 							"key": "token",
-							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA0ODMzMjY1LCJleHAiOjE2MDQ5MTk2NjUsImlhdCI6MTYwNDgzMzI2NX0.bGjMLDkCZ6zSBVUxC3WtYgyo-af16aJEGXKAUg_6p5Y",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
 							"type": "string"
 						}
 					]
@@ -194,17 +635,18 @@
 				],
 				"body": {
 					"mode": "raw",
-					"raw": "{\r\n  \"editionStart\": \"2020-11-15T11:02:04.002Z\",\r\n  \"editionFinish\": \"2020-11-25T11:02:04.002Z\",\r\n  \"reportingStart\": \"2020-11-20T11:02:04.002Z\",\r\n   \"course\": {\r\n        \"name\": \"Informatyka\"\r\n    },\r\n    \"availableSubjectsIds\": [2],\r\n    \"availableInternshipTypesIds\": [8]\r\n}"
+					"raw": "{\r\n  \"editionStart\": \"2020-11-15T11:02:04.002Z\",\r\n  \"editionFinish\": \"2020-11-25T11:02:04.002Z\",\r\n  \"reportingStart\": \"2020-11-20T11:02:04.002Z\",\r\n   \"course\": {\r\n        \"id\": 1,\r\n        \"name\": \"Informatyka\",\r\n        \"nameEng\": \"Informatics\"\r\n    },\r\n    \"availableSubjectsIds\": [2],\r\n    \"availableInternshipTypesIds\": [8]\r\n}"
 				},
 				"url": {
-					"raw": "http://localhost:8080/editionManagement",
+					"raw": "http://localhost:8080/management/edition",
 					"protocol": "http",
 					"host": [
 						"localhost"
 					],
 					"port": "8080",
 					"path": [
-						"editionManagement"
+						"management",
+						"edition"
 					]
 				}
 			},
@@ -218,7 +660,7 @@
 					"bearer": [
 						{
 							"key": "token",
-							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA0ODMzMjY1LCJleHAiOjE2MDQ5MTk2NjUsImlhdCI6MTYwNDgzMzI2NX0.bGjMLDkCZ6zSBVUxC3WtYgyo-af16aJEGXKAUg_6p5Y",
+							"value": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1bmlxdWVfbmFtZSI6ImZpcnN0bmFtZSIsImZhbWlseV9uYW1lIjoibGFzdG5hbWUiLCJQZXJzb25OdW1iZXIiOiIxIiwibmJmIjoxNjA2NTk2MzI5LCJleHAiOjE2MDY2ODI3MjksImlhdCI6MTYwNjU5NjMyOX0.O-dLJNI3-tNj96xOpz8LE7zrysmJkN069A3Zku2A7S0",
 							"type": "string"
 						}
 					]
@@ -233,17 +675,18 @@
 				],
 				"body": {
 					"mode": "raw",
-					"raw": "{\r\n  \"id\": \"138da8a3-855c-4b17-9bd2-5f357679efa9\",\r\n  \"editionStart\": \"2020-11-15T11:02:04.002Z\",\r\n  \"editionFinish\": \"2020-11-20T11:02:04.002Z\",\r\n  \"reportingStart\": \"2020-11-17T11:02:04.002Z\",\r\n   \"course\": {\r\n        \"name\": \"Informatyka\"\r\n    },\r\n    \"availableSubjectsIds\": [3],\r\n    \"availableInternshipTypesIds\": [3]\r\n}"
+					"raw": "{\r\n  \"id\": \"138da8a3-855c-4b17-9bd2-5f357679efa9\",\r\n  \"editionStart\": \"2020-11-15T11:02:04.002Z\",\r\n  \"editionFinish\": \"2020-11-20T11:02:04.002Z\",\r\n  \"reportingStart\": \"2020-11-17T11:02:04.002Z\",\r\n   \"course\": {\r\n        \"id\": 2,\r\n        \"name\": \"Inżynieria Biomedyczna\",\r\n        \"nameEng\": \"Biomedical Engineering\"\r\n    },\r\n    \"availableSubjectsIds\": [3],\r\n    \"availableInternshipTypesIds\": [3]\r\n}"
 				},
 				"url": {
-					"raw": "http://localhost:8080/editionManagement",
+					"raw": "http://localhost:8080/management/editions",
 					"protocol": "http",
 					"host": [
 						"localhost"
 					],
 					"port": "8080",
 					"path": [
-						"editionManagement"
+						"management",
+						"editions"
 					]
 				}
 			},
@@ -276,15 +719,16 @@
 					}
 				],
 				"url": {
-					"raw": "http://localhost:8080/editionManagement/bbc401c3-2d99-4142-bbb7-24c345d1fb21",
+					"raw": "http://localhost:8080/management/editions/be1a4439-0360-477c-85c5-e28bc8542883",
 					"protocol": "http",
 					"host": [
 						"localhost"
 					],
 					"port": "8080",
 					"path": [
-						"editionManagement",
+						"management",
-						"bbc401c3-2d99-4142-bbb7-24c345d1fb21"
+						"editions",
+						"be1a4439-0360-477c-85c5-e28bc8542883"
 					]
 				}
 			},
@@ -419,6 +863,5 @@
 			},
 			"response": []
 		}
-	],
+	]
-	"protocolProfileBehavior": {}
 }

README.MD

@@ -0,0 +1,49 @@
+# Uruchomienie
+
+Aby uruchomić środowisko deweloperskie wystarczy
+
+```bash
+docker build -f ./InternshipSystem.Api/Dockerfile -t internship.api .
+docker-compose -f ./.docker/docker-compose.yaml --build --volumes
+```
+
+# Opis struktury
+
+Opis struktury projektu
+
+## src/
+
+zawiera kod podzielony na 3 projekty
+
+- Api - Definicja interfejsu wystawianego dla częsci frontendowej
+- Core - Logika biznesowa aplikacji, definicja domeny.
+- Repository - Definicja repozytorium EFCore
+
+## test/
+
+Zawiera testy jednostkowe projektu. Przy pisaniu wykorzystano Machine-Specification
+
+## .build/
+
+Folder zawierający pliki definiujące CI/CD projektu
+
+## .docker/
+
+Folder zawiera pliki docker-compose przeznaczone do uruchamiania środowiska deweloperskiego, stanowiące również dokumentacje zmiennych środowiskowych konfigurujących projekt
+
+```yaml
+CONNECTIONSTRINGS__INTERNSHIPDATABASE: "Host=db.postgres;Port=5432;Database=postgres;Username=postgres;Password=password"
+ASPNETCORE_ENVIRONMENT: Development
+ASPNETCORE_URLS: http://+:80
+SECURITYOPTIONS__SECRET: secret
+SECURITYOPTIONS__EXPIRATION: 1440     # 24h in minutes
+SECURITYOPTIONS__BASEURL: https://logowanie.pg.edu.pl
+SECURITYOPTIONS__TOKENPATH: /oauth2.0/accessToken
+SECURITYOPTIONS__PROFILEPATH: /oauth2.0/profile
+SECURITYOPTIONS__CLIENTID: PraktykiClientId
+SECURITYOPTIONS__REDIRECTURL: https://system-praktyk.net/user/login/check/pg
+```
+
+## props/
+
+Folder ze współdzieloną konfiguracją dla grup projektów, np. wersji bibliotek używanych przy pisaniu testów.

global.json

@@ -1,5 +0,0 @@
-{
-  "sdk": {
-    "version": "3.1.301"
-  }
-}

src/InternshipSystem.Api/ApiProfile.cs

@@ -3,6 +3,7 @@ using AutoMapper;
 using InternshipSystem.Api.Queries;
 using InternshipSystem.Api.Result;
 using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
 using InternshipSystem.Core.Entity.Internship;
 using InternshipSystem.Core.UglyOrmArtifacts;
 
@@ -20,7 +21,7 @@ namespace InternshipSystem.Api
                     opt => opt.MapFrom(edition => edition.IsOpen ? "Open" : "Archival"));
 
             CreateMap<Edition, EditionManagementResult>();
-
+            
             CreateMap<Edition, EditionDetailsResult>();
             
             CreateMap<Edition, EditionConfigurationResult>();
@@ -33,6 +34,11 @@ namespace InternshipSystem.Api
             CreateMap<EditionInternshipType, InternshipType>()
                 .IncludeMembers(eit => eit.InternshipType);
 
+            CreateMap<ReportFieldEdition, ReportField>()
+                .IncludeMembers(e => e.Field);
+
+            CreateMap<ReportField, ReportField>();
+
             CreateMap<InternshipType, InternshipType>();
         }
     }

src/InternshipSystem.Api/Controllers/CourseController.cs

@@ -0,0 +1,127 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using InternshipSystem.Api.Queries;
+using InternshipSystem.Api.Security;
+using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
+using InternshipSystem.Repository;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace InternshipSystem.Api.Controllers
+{
+    [ApiController]
+    [Route("management/course")]
+    public class CourseController : ControllerBase
+    {
+        private InternshipDbContext Context { get; }
+        
+        public CourseController(InternshipDbContext context)
+        {
+            Context = context;
+        }
+
+        [HttpGet]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult<IReadOnlyCollection<Course>>> GetCourses(CancellationToken cancellationToken) =>
+            await Context.Courses
+                .ToListAsync(cancellationToken);
+
+        [HttpGet("{courseId}")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult<Course>> GetCourse(long courseId, CancellationToken cancellationToken)
+        {
+            var course = await Context.Courses
+                .Where(c => c.Id == courseId)
+                .FirstOrDefaultAsync(cancellationToken);
+
+            if (course == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(course);
+        }
+        
+        [HttpPut]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> UpsertCourse([FromBody] CourseForm courseForm, CancellationToken cancellationToken)
+        {
+            var validator = new CourseForm.Validator();
+            var validationResult = await validator.ValidateAsync(courseForm, cancellationToken);
+
+            if (!validationResult.IsValid)
+            {
+                return BadRequest(validationResult.ToString());
+            }
+
+            if (courseForm.Id.HasValue)
+            {
+                var course = await Context.Courses.FindAsync(courseForm.Id.Value);
+
+                if (course == null)
+                {
+                    return NotFound();
+                }
+
+                course.UpdateCourse(courseForm.Name, courseForm.NameEng);
+            }
+            else
+            {
+                var newCourse = Course.CreateCourse(courseForm.Name, courseForm.NameEng);
+
+                await Context.Courses.AddAsync(newCourse, cancellationToken);
+            }
+
+            await Context.SaveChangesAsync(cancellationToken);
+            return Ok();
+        }
+
+        [HttpDelete("{courseId}")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status400BadRequest)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [ProducesResponseType(StatusCodes.Status409Conflict)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> DeleteCourse(long courseId, CancellationToken cancellationToken)
+        {
+            var courseToDelete = await Context.Courses
+                .Where(c => c.Id == courseId)
+                .FirstOrDefaultAsync(cancellationToken);
+
+            if (courseToDelete == null)
+            {
+                return NotFound();
+            }
+
+            var referencedEditions =
+                await Context.Editions
+                    .Include(e => e.Course)
+                    .Where(e => e.Course.Id == courseToDelete.Id)
+                    .CountAsync(cancellationToken);
+
+            if (referencedEditions > 0)
+            {
+                return Conflict();
+            }
+
+            Context.Courses.Remove(courseToDelete);
+            await Context.SaveChangesAsync(cancellationToken);
+            return Ok();
+        }
+    }
+}

src/InternshipSystem.Api/Controllers/DocumentManagementController.cs

@@ -0,0 +1,110 @@
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using InternshipSystem.Api.Security;
+using InternshipSystem.Core;
+using InternshipSystem.Repository;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace InternshipSystem.Api.Controllers
+{
+
+    [ApiController]
+    [Route("management/document")]
+    public class DocumentManagementController : ControllerBase
+    {
+        private InternshipDbContext Context { get; }
+        
+        public DocumentManagementController(InternshipDbContext context)
+        {
+            Context = context;
+        }
+        
+        [HttpDelete("{documentId}/delete")]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> DeleteDocument(long documentId, CancellationToken ct)
+        {
+            var internship = await Context.Internships
+                .Include(i => i.Documentation)
+                .FirstOrDefaultAsync(i => i.Documentation.Any(d => d.Id.Equals(documentId)), ct);
+
+            if (internship == null)
+            {
+                return NotFound();
+            }
+            
+            internship.RemoveDocument(documentId);
+
+            await Context.SaveChangesAsync(ct);
+            
+            return Ok();
+        }
+
+        [HttpPut("{documentId}/accept")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> AcceptDocument(long documentId, [FromBody] string comment, CancellationToken token)
+        {
+            var internship = await Context.Internships
+                .Include(i => i.Documentation)
+                .FirstOrDefaultAsync(i => i.Documentation.Any(d => d.Id.Equals(documentId)), token);
+
+            if (internship == null)
+            {
+                return NotFound();
+            }
+            
+            var document = internship.Documentation
+                .FirstOrDefault(d => d.Id.Equals(documentId));
+            
+            if (document == null)
+            {
+                return NotFound();
+            }
+
+            document.State = DocumentState.Accepted;
+            document.ChangeStateComment = string.IsNullOrEmpty(comment) ? null : comment;
+            
+            await Context.SaveChangesAsync(token);
+            
+            return Ok();
+        }
+        
+        [HttpPut("{documentId}/reject")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> RejectDocument(long documentId, [FromBody] string comment, CancellationToken token)
+        {
+            var internship = await Context.Internships
+                .Include(i => i.Documentation)
+                .FirstOrDefaultAsync(i => i.Documentation.Any(d => d.Id.Equals(documentId)), token);
+
+            if (internship == null)
+            {
+                return NotFound();
+            }
+            
+            var document = internship.Documentation
+                .FirstOrDefault(d => d.Id.Equals(documentId));
+            
+            if (document == null)
+            {
+                return NotFound();
+            }
+
+            document.State = DocumentState.Rejected;
+            document.ChangeStateComment = string.IsNullOrEmpty(comment) ? null : comment;
+            
+            await Context.SaveChangesAsync(token);
+            
+            return Ok();
+        }
+    }
+}

src/InternshipSystem.Api/Controllers/DocumentsController.cs

@@ -96,21 +96,24 @@ namespace InternshipSystem.Api.Controllers
                 await _context.Entry(edition)
                     .Collection(e => e.Internships)
                     .Query()
-                    .Include(i => i.Documentation)
+                    .Include(i  => i.Documentation)
                     .FirstAsync(i => i.Student.Id == user.PersonNumber, cancellationToken);
 
-            var document = internship.Documentation.First(d => d.Id == documentId);
+            var document = await _context.Entry(internship)
+                .Collection(i => i.Documentation)
+                .Query()
+                .Include(d => d.Scan)
+                .FirstAsync(d => d.Id == documentId, cancellationToken);
+
+            document.Scan ??= new DocumentScan();
+
+            document.Scan.Size = memoryStream.Length;
+            document.Scan.Filename = documentScan.FileName;
+            document.Scan.Mime = _fileValidator.GetFileMime(memoryStream.ToArray());
+            document.Scan.File = memoryStream.ToArray();
 
-            document.Scan = new DocumentScan
-            {
-                File = memoryStream.ToArray(),
-                Size = memoryStream.Length,
-                Filename = documentScan.FileName,
-                Mime = _fileValidator.GetFileMime(memoryStream.ToArray())
-            };
-            
             document.State = DocumentState.Submitted;
-            
+
             await _context.SaveChangesAsync(cancellationToken);
             
             return Ok();

src/InternshipSystem.Api/Controllers/EditionController.cs

@@ -99,6 +99,8 @@ namespace InternshipSystem.Api.Controllers
             var edition = 
                 await Context.Editions
                     .Include(e => e.AvailableSubjects)
+                    .Include(e => e.ReportSchema)
+                        .ThenInclude(e => e.Field)
                     .Include(e => e.Course)
                     .Where(e => e.Id == user.EditionId)
                     .ProjectTo<EditionConfigurationResult>(Mapper.ConfigurationProvider)

src/InternshipSystem.Api/Controllers/EditionManagementController.cs

@@ -19,7 +19,7 @@ using Microsoft.EntityFrameworkCore;
 namespace InternshipSystem.Api.Controllers
 {
     [ApiController]
-    [Route("editionManagement")]
+    [Route("management/editions")]
     public class EditionManagementController : ControllerBase
     {
         private InternshipDbContext Context { get; }
@@ -38,10 +38,13 @@ namespace InternshipSystem.Api.Controllers
         public async Task<ActionResult<IReadOnlyCollection<EditionManagementResult>>> GetEditions([FromQuery] EditionSearchQuery searchQuery, CancellationToken token) =>
             await Context.Editions
                 .Include(e => e.Course)
+                .Where(p => !searchQuery.Course.HasValue || p.Course.Id == searchQuery.Course)
                 .ProjectTo<EditionManagementResult>(Mapper.ConfigurationProvider)
                 .Skip(searchQuery.Page * searchQuery.PerPage)
                 .Take(searchQuery.PerPage)
                 .ToListAsync(token);
+        
+        
 
         [HttpGet("{editionId}")]
         [ProducesResponseType(StatusCodes.Status200OK)]
@@ -56,6 +59,8 @@ namespace InternshipSystem.Api.Controllers
                     .ThenInclude(s => s.Subject)
                 .Include(e => e.AvailableInternshipTypes)
                     .ThenInclude(i => i.InternshipType)
+                .Include(e => e.ReportSchema)
+                    .ThenInclude(er => er.Field)
                 .Where(e => e.Id == editionId)
                 .ProjectTo<EditionDetailsResult>(Mapper.ConfigurationProvider)
                 .FirstOrDefaultAsync(token);
@@ -67,11 +72,10 @@ namespace InternshipSystem.Api.Controllers
 
             return Ok(edition);
         }
-        
+
         [HttpPut]
         [ProducesResponseType(StatusCodes.Status200OK)]
         [ProducesResponseType(StatusCodes.Status400BadRequest)]
-        [ProducesResponseType(StatusCodes.Status400BadRequest)]
         [ProducesResponseType(StatusCodes.Status401Unauthorized)]
         [ProducesResponseType(StatusCodes.Status404NotFound)]
         [Authorize(Policy = Policies.IsOverseer)]
@@ -84,15 +88,13 @@ namespace InternshipSystem.Api.Controllers
             {
                 return BadRequest(validationResult.ToString());
             }
-
-            //TODO: resolve courses (one for each edition or dictionary)
-            editionForm.Course.Id = 0;
             
             if (editionForm.Id.HasValue)
             {
                 var editionToUpdate = await Context.Editions
                     .Include(e => e.AvailableSubjects)
                     .Include(e => e.AvailableInternshipTypes)
+                    .Include(e => e.ReportSchema)
                     .FirstOrDefaultAsync(e => e.Id == editionForm.Id.Value, token);
 
                 if (editionToUpdate == null)
@@ -101,7 +103,7 @@ namespace InternshipSystem.Api.Controllers
                 }
                 
                 editionToUpdate.UpdateEdition(editionForm.EditionStart, editionForm.EditionFinish, editionForm.ReportingStart,
-                    editionForm.Course, editionForm.AvailableSubjectsIds, editionForm.AvailableInternshipTypesIds);
+                    editionForm.Course, editionForm.AvailableSubjectsIds, editionForm.AvailableInternshipTypesIds, editionForm.ReportSchema);
                 
                 if (!editionToUpdate.IsValidDates)
                 {
@@ -112,7 +114,7 @@ namespace InternshipSystem.Api.Controllers
             {
                 var newEdition = 
                     Edition.CreateEdition(editionForm.EditionStart.Value, editionForm.EditionFinish.Value, editionForm.ReportingStart.Value,
-                        editionForm.Course, editionForm.AvailableSubjectsIds, editionForm.AvailableInternshipTypesIds);
+                        editionForm.Course, editionForm.AvailableSubjectsIds, editionForm.AvailableInternshipTypesIds, editionForm.ReportSchema);
                 
                 if (!newEdition.IsValidDates)
                 {
@@ -138,6 +140,7 @@ namespace InternshipSystem.Api.Controllers
             var editionToDelete = await Context.Editions
                 .Include(e => e.AvailableSubjects)
                 .Include(e => e.AvailableInternshipTypes)
+                .Include(e => e.ReportSchema)
                 .FirstOrDefaultAsync(e => e.Id.Equals(editionId), token);
 
             if (editionToDelete == null)

src/InternshipSystem.Api/Controllers/InternshipManagementController.cs

@@ -0,0 +1,190 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using InternshipSystem.Api.Queries.SearchQuery;
+using InternshipSystem.Api.Security;
+using InternshipSystem.Core;
+using InternshipSystem.Core.Entity.Internship;
+using InternshipSystem.Repository;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace InternshipSystem.Api.Controllers
+{
+    [ApiController]
+    [Route("management/internship")]
+    public class InternshipManagementController : ControllerBase
+    {
+        private InternshipDbContext Context { get; }
+        
+        public InternshipManagementController(InternshipDbContext context)
+        {
+            Context = context;
+        }
+
+        [HttpGet]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult<IReadOnlyCollection<Internship>>> GetInternships([FromQuery] InternshipSearchQuery searchQuery, CancellationToken token)
+        {
+            var query =
+                Context.Internships
+                    .Include(i => i.Edition)
+                    .Include(i => i.InternshipRegistration)
+                    .Include(i => i.InternshipRegistration.Type)
+                    .Include(i => i.Student)
+                    .Include(i => i.Documentation)
+                    .Include(i => i.Report)
+                    .Where(i => !searchQuery.EditionId.HasValue || i.Edition.Id == searchQuery.EditionId)
+                    .Where(i => !searchQuery.InternshipState.HasValue || i.InternshipRegistration.State == searchQuery.InternshipState)
+                    .Where(i => !searchQuery.InternshipState.HasValue || i.Report.State == searchQuery.ReportState)
+                    .Where(i => !searchQuery.StudentAlbumNumber.HasValue || i.Student.AlbumNumber == searchQuery.StudentAlbumNumber)
+                    .Where(i => string.IsNullOrEmpty(searchQuery.StudentFirstName) || i.Student.FirstName.ToLower().Contains(searchQuery.StudentFirstName.ToLower()))
+                    .Where(i => string.IsNullOrEmpty(searchQuery.StudentLastName) || i.Student.LastName.ToLower().Contains(searchQuery.StudentLastName.ToLower()))
+                    .Where(i => !searchQuery.DocumentWithState.HasValue || i.Documentation.Any(d => d.State == searchQuery.DocumentWithState))
+                    .Skip(searchQuery.Page * searchQuery.PerPage)
+                    .Take(searchQuery.PerPage);
+            
+            if (searchQuery.OrderByField.ToLower().Equals("date"))
+            {
+                query = searchQuery.SortOrder.Equals(SortOrder.Desc) ? 
+                    query.OrderByDescending(i => i.InternshipRegistration.SubmissionDate) : 
+                    query.OrderBy(i => i.InternshipRegistration.SubmissionDate);
+            } 
+            else if (searchQuery.OrderByField.ToLower().Equals("internshipstate"))
+            {
+                query = searchQuery.SortOrder.Equals(SortOrder.Desc) ? 
+                    query.OrderByDescending(i => i.InternshipRegistration.State) : 
+                    query.OrderBy(i => i.InternshipRegistration.State);
+            }
+
+            var result = await query.ToListAsync(token);
+
+            return Ok(result);
+        }
+
+        [HttpGet("{internshipId}")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult<Internship>> GetInternship(long internshipId, CancellationToken token)
+        {
+            var internship = await Context.Internships
+                .Include(i => i.Student)
+                .Include(i => i.InternshipRegistration)
+                .Include(i => i.InternshipRegistration.Company)
+                .Include(i => i.InternshipRegistration.BranchAddress)
+                .Include(i => i.InternshipRegistration.Type)
+                .Include(i => i.InternshipRegistration.Subjects)
+                    .ThenInclude(subject => subject.Subject)
+                .Include(i => i.InternshipRegistration.Mentor)
+                .Include(i => i.Report)
+                .Include(i => i.Documentation)
+                .Include(i => i.Edition)
+                .Where(i => i.Id.Equals(internshipId))
+                .FirstOrDefaultAsync(token);
+
+            if (internship == null)
+            {
+                return NotFound();
+            }
+            
+            return Ok(internship);
+        }
+        
+        [HttpGet("{internshipId}/status")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> GetInternshipStatus(long internshipId, CancellationToken token)
+        {
+            var internship = await Context.Internships
+                .Include(i => i.InternshipRegistration)
+                .Include(i => i.Report)
+                .Include(i => i.Documentation)
+                .FirstOrDefaultAsync(i => i.Id.Equals(internshipId), token);
+
+            if (internship == null)
+            {
+                return NotFound();
+            }
+            
+            return new JsonResult(new { Errors = internship.ValidateStatus() });
+        }
+        
+        [HttpPut("{internshipId}/grade")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> GradeInternship(long internshipId, [FromBody] float grade, CancellationToken token)
+        {
+            var internship = await Context.Internships
+                .FirstOrDefaultAsync(i => i.Id.Equals(internshipId), token);
+
+            if (internship == null)
+            {
+                return NotFound();
+            }
+
+            internship.Grade = grade;
+            await Context.SaveChangesAsync(token);
+            
+            return new JsonResult(new { Errors = internship.ValidateStatus() });
+        }
+        
+        [HttpPut("{internshipId}/registration/accept")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> AcceptInternshipRegistration(long internshipId, [FromBody] string comment, CancellationToken token)
+        {
+            var internship = await Context.Internships
+                .Include(i => i.InternshipRegistration)
+                .FirstOrDefaultAsync(i => i.Id.Equals(internshipId), token);
+
+            if (internship == null)
+            {
+                return NotFound();
+            }
+
+            internship.InternshipRegistration.State = DocumentState.Accepted;
+            internship.InternshipRegistration.ChangeStateComment = string.IsNullOrEmpty(comment) ? null : comment;
+            
+            await Context.SaveChangesAsync(token);
+            
+            return Ok();
+        }
+        
+        [HttpPut("{internshipId}/registration/reject")]
+        [ProducesResponseType(StatusCodes.Status200OK)]
+        [ProducesResponseType(StatusCodes.Status401Unauthorized)]
+        [ProducesResponseType(StatusCodes.Status404NotFound)]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> RejectInternshipRegistration(long internshipId, [FromBody] string comment, CancellationToken token)
+        {
+            var internship = await Context.Internships
+                .Include(i => i.InternshipRegistration)
+                .FirstOrDefaultAsync(i => i.Id.Equals(internshipId), token);
+            
+            if (internship == null)
+            {
+                return NotFound();
+            }
+
+            internship.InternshipRegistration.State = DocumentState.Rejected;
+            internship.InternshipRegistration.ChangeStateComment = string.IsNullOrEmpty(comment) ? null : comment;
+
+            await Context.SaveChangesAsync(token);
+
+            return Ok();
+        }
+    }
+}

src/InternshipSystem.Api/Controllers/InternshipRegistrationController.cs

@@ -47,7 +47,7 @@ namespace InternshipSystem.Api.Controllers
                     .ThenInclude(t => t.Subject)
                 .FirstAsync(e => e.Id == user.EditionId, cancellationToken);
 
-            var internshipRegistration =
+            var internship =
                 await _context
                     .Entry(edition)
                     .Collection(e => e.Internships)
@@ -62,12 +62,11 @@ namespace InternshipSystem.Api.Controllers
                         .ThenInclude(c => c.Type)
                     .Include(i => i.InternshipRegistration)
                         .ThenInclude(c => c.Subjects)
+                    .Include(i => i.Documentation)
                     .Where(i => i.Student.Id == user.PersonNumber)
-                    .Select(i => i.InternshipRegistration)
                     .FirstAsync(cancellationToken);
-            
+
-            
+            var useCase = new UpdateInternshipRegistrationUseCase(_context, internship, edition, user);
-            var useCase = new UpdateInternshipRegistrationUseCase(_context, internshipRegistration, edition, user);
 
             try
             {

src/InternshipSystem.Api/Controllers/ReportController.cs

@@ -0,0 +1,62 @@
+using System.Threading;
+using System.Threading.Tasks;
+using InternshipSystem.Api.Security;
+using InternshipSystem.Core.ValueObject;
+using InternshipSystem.Repository;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+namespace InternshipSystem.Api.Controllers
+{
+    [Route("internship/report")]
+    public class ReportController : ControllerBase
+    {
+        private readonly InternshipDbContext _context;
+
+        public ReportController(InternshipDbContext context)
+        {
+            _context = context;
+        }
+        
+        [HttpPost]
+        [Authorize(Policy = Policies.RegisteredOnly)]
+        public async Task<ActionResult> PostReport([FromBody] JObject reportValue, [FromServices] User user, CancellationToken ct)
+        {
+            var edition = await _context.Editions
+                .FindAsync(user.EditionId);
+            
+            var internship = await _context.Entry(edition)
+                .Collection(e => e.Internships)
+                .Query()
+                .Include(i => i.Report)
+                .Include(i => i.Documentation)
+                .SingleAsync(i => i.Student.Id == user.PersonNumber, ct);
+
+            internship.Report.UpdateReport(reportValue.ToString(Formatting.None));
+            internship.AddNewDocument("", DocumentType.InternshipEvaluation);
+            
+            await _context.SaveChangesAsync(ct);
+
+            return Ok();
+        }
+        
+        [HttpGet]
+        [Authorize(Policy = Policies.RegisteredOnly)]
+        public async Task<ActionResult> GetReport([FromServices] User user, CancellationToken ct)
+        {
+            var edition = await _context.Editions
+                .FindAsync(user.EditionId);
+            
+            var internship = await _context.Entry(edition)
+                .Collection(e => e.Internships)
+                .Query()
+                .Include(i => i.Report)
+                .SingleAsync(i => i.Student.Id == user.PersonNumber, ct);
+
+            return Ok(JsonConvert.DeserializeObject(internship.Report.Value));
+        }
+    }
+}

src/InternshipSystem.Api/Controllers/ReportFieldsController.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AutoMapper;
+using InternshipSystem.Api.Queries.SearchQuery;
+using InternshipSystem.Api.Security;
+using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
+using InternshipSystem.Repository;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+
+namespace InternshipSystem.Api.Controllers
+{
+    [Route("management/report")]
+    public class ReportFieldsController : ControllerBase
+    {
+        private readonly InternshipDbContext _context;
+        private readonly IMapper _mapper;
+
+        public ReportFieldsController(InternshipDbContext context, IMapper mapper)
+        {
+            _context = context;
+            _mapper = mapper;
+        }
+
+        [HttpGet("fields")]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<IEnumerable<ReportField>> GetFields(FieldSearchQuery searchQuery, CancellationToken ct) =>
+            await _context.ReportFields
+                .Where(c => c.Label.ToLower().Contains(searchQuery.Label.ToLower()))
+                .OrderBy(o => o.Label)
+                .Skip(searchQuery.Page * searchQuery.PerPage)
+                .Take(searchQuery.PerPage)
+                .ToListAsync(ct);
+
+        [HttpPost("fields")]
+        [Authorize(Policy = Policies.IsOverseer)]
+        public async Task<ActionResult> CreateField([FromBody] FieldCreateRequest request, CancellationToken ct)
+        {
+            ReportField field;
+
+            switch (request.FieldType)
+            {
+                case FieldType.LongText:
+                case FieldType.ShortText:
+                    field = new ReportField(request.Label, request.LabelEng, request.Description, request.DescriptionEng, request.FieldType);
+                    break;
+                case FieldType.Select:
+                case FieldType.Radial:
+                case FieldType.Checkbox:
+                    field = new ReportChoiceField(request.Label, request.LabelEng, request.Description, request.DescriptionEng, request.FieldType, request.Choices);
+                    break;
+                default:
+                    return BadRequest("Unknown field type");
+            }
+
+            try
+            {
+                await _context.ReportFields.AddAsync(field, ct);
+                await _context.SaveChangesAsync(ct);
+            }
+            catch (Exception e)
+            {
+                return BadRequest("Failed");
+            }
+
+            return Ok();
+        }
+    }
+
+    public class FieldSearchQuery : SearchQuery
+    {
+        public string Label { get; set; } = "";
+    }
+
+    public class FieldCreateRequest
+    {
+        public long? Id { get; set; }
+        public string Label { get; set; }
+        public string LabelEng { get; set; }
+        public string Description { get; set; }
+        public string DescriptionEng { get; set; }
+        public FieldType FieldType { get; set; }
+        public string[] Choices { get; set; }
+    }
+}

src/InternshipSystem.Api/Controllers/StaticPagesController.cs

@@ -121,7 +121,7 @@ namespace InternshipSystem.Api.Controllers
                 {
                     AccessName = staticPageForm.AccessName.ToLower().Trim(),
                     Title = staticPageForm.Title,
-                    TitleEng = staticPageForm.Title,
+                    TitleEng = staticPageForm.TitleEng,
                     Content = staticPageForm.Content,
                     ContentEng = staticPageForm.ContentEng,
                 };

src/InternshipSystem.Api/Queries/CourseForm.cs

@@ -0,0 +1,23 @@
+using FluentValidation;
+
+namespace InternshipSystem.Api.Queries
+{
+    public class CourseForm
+    {
+        public long? Id { get; set; }
+        public string Name { get; set; }
+        public string NameEng { get; set; }
+        
+        public class Validator : AbstractValidator<CourseForm>
+        {
+            public Validator()
+            {
+                RuleFor(c => c.Id).NotNull()
+                    .When(c => string.IsNullOrWhiteSpace(c.Name));
+
+                RuleFor(c => c.Name).NotEmpty()
+                    .When(c => !c.Id.HasValue);
+            }
+        }
+    }
+}

src/InternshipSystem.Api/Queries/EditionForm.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using FluentValidation;
 using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
 using InternshipSystem.Core.Entity.Internship;
 
 namespace InternshipSystem.Api.Queries
@@ -15,6 +16,7 @@ namespace InternshipSystem.Api.Queries
         public Course Course { get; set; }
         public List<long> AvailableSubjectsIds { get; set; } = new List<long>();
         public List<long> AvailableInternshipTypesIds { get; set; } = new List<long>();
+        public List<long> ReportSchema { get; set; } = new List<long>();
         
         public class Validator : AbstractValidator<EditionForm>
         {

src/InternshipSystem.Api/Queries/SearchQuery/EditionSearchQuery.cs

@@ -2,6 +2,6 @@
 {
     public class EditionSearchQuery : SearchQuery
     {
-        
+        public long? Course { get; set; }
     }
 }

src/InternshipSystem.Api/Queries/SearchQuery/InternshipSearchQuery.cs

@@ -0,0 +1,22 @@
+using System;
+using InternshipSystem.Core;
+
+namespace InternshipSystem.Api.Queries.SearchQuery
+{
+    public class InternshipSearchQuery : SearchQuery
+    {
+        public Guid? EditionId { get; set; } = null;
+        public DocumentState? InternshipState { get; set; } = null;
+        public DocumentState? ReportState { get; set; }
+        public int? StudentAlbumNumber { get; set; } = null;
+        public string StudentFirstName { get; set; } = "";
+        public string StudentLastName { get; set; } = "";
+        /// <summary>
+        /// SortValue: Date, InternshipState
+        /// </summary>
+        public string OrderByField { get; set; } = "";
+        public SortOrder SortOrder { get; set; } = SortOrder.None;
+
+        public DocumentState? DocumentWithState { get; set; }
+    }
+}

src/InternshipSystem.Api/Queries/SearchQuery/SortOrder.cs

@@ -0,0 +1,9 @@
+namespace InternshipSystem.Api.Queries.SearchQuery
+{
+    public enum SortOrder
+    {
+        Asc,
+        Desc,
+        None
+    }
+}

src/InternshipSystem.Api/Result/EditionConfigurationResult.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
 using InternshipSystem.Core.Entity.Internship;
 using InternshipSystem.Core.UglyOrmArtifacts;
 
@@ -9,6 +10,7 @@ namespace InternshipSystem.Api.Result
     public class EditionConfigurationResult
     {
         public List<InternshipSubject> AvailableSubjects { get; set; }
+        public List<ReportField> ReportSchema { get; set; }
         public Course Course { get; set; }
         public DateTime EditionStart { get; set; }
         public DateTime EditionFinish { get; set; }

src/InternshipSystem.Api/Result/EditionDetailsResult.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
 using InternshipSystem.Core.Entity.Internship;
 
 namespace InternshipSystem.Api.Result
@@ -14,5 +15,6 @@ namespace InternshipSystem.Api.Result
         public Course Course { get; set; }
         public List<InternshipSubject> AvailableSubjects { get; set; }
         public List<InternshipType> AvailableInternshipTypes { get; set; }
+        public List<ReportField> ReportSchema { get; set; }
     }
 }

src/InternshipSystem.Api/Result/EditionManagementResult.cs

@@ -1,5 +1,6 @@
 using System;
 using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
 
 namespace InternshipSystem.Api.Result
 {

src/InternshipSystem.Api/UseCases/UpdateInternshipRegistrationUseCase.cs

@@ -9,6 +9,7 @@ using InternshipSystem.Api.Security;
 using InternshipSystem.Core;
 using InternshipSystem.Core.Entity.Internship;
 using InternshipSystem.Core.UglyOrmArtifacts;
+using InternshipSystem.Core.ValueObject;
 using InternshipSystem.Repository;
 using Microsoft.EntityFrameworkCore;
 
@@ -17,25 +18,27 @@ namespace InternshipSystem.Api.UseCases
     public class UpdateInternshipRegistrationUseCase
     {
         private readonly InternshipDbContext _dbContext;
+        private readonly Internship _internship;
         private readonly Edition _edition;
         private readonly User _user;
         private readonly InternshipRegistration subjectRegistration;
 
         public UpdateInternshipRegistrationUseCase(InternshipDbContext dbContext,
-            InternshipRegistration internshipRegistration, Edition edition, User user)
+            Internship internship, Edition edition, User user)
         {
             _dbContext = dbContext;
+            _internship = internship;
             _edition = edition;
             _user = user;
-            subjectRegistration = internshipRegistration;
+            _internship = internship;
+            subjectRegistration = internship.InternshipRegistration;
         }
 
-        public async Task<(DocumentState State, IEnumerable<string>)> UpdateInternshipRegistration(
+        public async Task<(DocumentState State, IEnumerable<ErrorDescription>)> UpdateInternshipRegistration(
             UpdateRegistrationForm registrationCommand,
             CancellationToken cancellationToken)
         {
-            subjectRegistration.Start = registrationCommand.Start ?? subjectRegistration.Start;
+            UpdateTimeFrame(registrationCommand);
-            subjectRegistration.End = registrationCommand.End ?? subjectRegistration.End;
             subjectRegistration.DeclaredHours = registrationCommand.Hours ?? subjectRegistration.DeclaredHours;
 
             if (registrationCommand.Type.HasValue)
@@ -61,9 +64,43 @@ namespace InternshipSystem.Api.UseCases
             return subjectRegistration.ValidateStatus(_edition);
         }
 
+        private void UpdateTimeFrame(UpdateRegistrationForm registrationCommand)
+        {
+            subjectRegistration.Start = registrationCommand.Start ?? subjectRegistration.Start;
+            subjectRegistration.End = registrationCommand.End ?? subjectRegistration.End;
+
+            if (!_edition.IsDateDuringEdition(subjectRegistration.Start, subjectRegistration.End))
+            {
+                _internship.AddNewDocument("", DocumentType.OutsideTermApproval);
+            }
+            else
+            {
+                _internship.RemoveDocument(DocumentType.OutsideTermApproval);
+            }
+        }
+
         private void UpdateInternshipType(long typeId)
         {
             var editionInternshipType = _edition.AvailableInternshipTypes.FirstOrDefault(i => i.InternshipTypeId == typeId);
+
+            if (editionInternshipType?.InternshipType.RequireDeansApproval == true)
+            {
+                _internship.AddNewDocument("", DocumentType.InternshipTypeApproval);
+            }
+            else
+            {
+                _internship.RemoveDocument(DocumentType.InternshipTypeApproval);
+            }
+            
+            if (editionInternshipType?.InternshipType.RequireInsurance == true)
+            {
+                _internship.AddNewDocument("", DocumentType.NnwInsurance);
+            }
+            else
+            {
+                _internship.RemoveDocument(DocumentType.NnwInsurance);
+            }
+            
             subjectRegistration.Type = editionInternshipType?.InternshipType ?? subjectRegistration.Type;
         }
 

src/InternshipSystem.Core/Entity/Course.cs

@@ -1,8 +1,24 @@
-namespace InternshipSystem.Core
+using System.Collections.Generic;
+
+namespace InternshipSystem.Core.Entity
 {
     public class Course
     {
         public long Id { get; set; }
         public string Name { get; set; }
+        public string NameEng { get; set; }
+
+        public static Course CreateCourse(string name, string nameEng) =>
+            new Course
+            {
+                Name = name,
+                NameEng = nameEng,
+            };
+
+        public void UpdateCourse(string name, string nameEng)
+        {
+            Name = name;
+            NameEng = nameEng;
+        }
     }
 }

src/InternshipSystem.Core/Entity/Document.cs

@@ -9,7 +9,7 @@ namespace InternshipSystem.Core
         public DocumentScan Scan { get; set; }
         public DocumentType Type { get; set; }
         public DocumentState State { get; set; }
-        public string RejectionReason { get; set; }
+        public string ChangeStateComment { get; set; }
     }
 
     public class DocumentScan

src/InternshipSystem.Core/Entity/Edition.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using InternshipSystem.Core.Entity;
 using InternshipSystem.Core.Entity.Internship;
 using InternshipSystem.Core.UglyOrmArtifacts;
 
@@ -16,11 +17,12 @@ namespace InternshipSystem.Core
         public List<Internship> Internships { get; set; }
         public List<EditionSubject> AvailableSubjects { get; set; }
         public List<EditionInternshipType> AvailableInternshipTypes { get; set; }
+        public List<ReportFieldEdition> ReportSchema { get; set; }
 
         public bool IsOpen => EditionFinish < DateTime.Today;
 
         public static Edition CreateEdition(DateTime start, DateTime end, DateTime reportingStart, Course course,
-            IEnumerable<long> subjectsIds, IEnumerable<long> internshipTypesIds)
+            IEnumerable<long> subjectsIds, IEnumerable<long> internshipTypesIds, IEnumerable<long> reportFieldIds)
         {
             var newEdition = CreateEdition(start, end, reportingStart, course);
 
@@ -41,6 +43,15 @@ namespace InternshipSystem.Core
                         InternshipTypeId = i,
                     })
                     .ToList();
+            
+            newEdition.ReportSchema =
+                reportFieldIds
+                    .Select(i => new ReportFieldEdition
+                    {
+                        Edition = newEdition,
+                        ReportFieldId = i,
+                    })
+                    .ToList();
 
             return newEdition;
         }
@@ -55,11 +66,12 @@ namespace InternshipSystem.Core
                 Course = course,
                 AvailableSubjects = new List<EditionSubject>(),
                 AvailableInternshipTypes = new List<EditionInternshipType>(),
+                ReportSchema = new List<ReportFieldEdition>()
             };
         }
 
         public void UpdateEdition(DateTime? start, DateTime? end, DateTime? reportingStart, Course course,
-            IEnumerable<long> subjectsIds, IEnumerable<long> internshipTypesIds)
+            IEnumerable<long> subjectsIds, IEnumerable<long> internshipTypesIds, IEnumerable<long> reportFieldIds)
         {
             EditionStart = start ?? EditionStart;
             EditionFinish = end ?? EditionFinish;
@@ -87,6 +99,17 @@ namespace InternshipSystem.Core
                         })
                         .ToList();
             }
+
+            if (reportFieldIds != null)
+            {
+                ReportSchema =
+                    reportFieldIds
+                        .Select(i => new ReportFieldEdition
+                        {
+                            ReportFieldId = i,
+                        })
+                        .ToList();
+            }
         }
 
         public void RegisterInternship(Student student)
@@ -97,7 +120,7 @@ namespace InternshipSystem.Core
             }
             
             var internship = Internship.CreateStudentsInternship(student);
-            
+
             Internships.Add(internship);
         }
 

src/InternshipSystem.Core/Entity/Internship/Extensions.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+using System.Linq;
+using FluentValidation.Results;
+using InternshipSystem.Core.Entity.Internship;
+
+namespace InternshipSystem.Core
+{
+    static internal class Extensions
+    {
+        public static IEnumerable<ErrorDescription> ToErrorDescription(this ValidationResult result)
+        {
+            return result.Errors.Select(failure => new ErrorDescription { Key = failure.ErrorCode, Parameters = failure.FormattedMessagePlaceholderValues });
+        }
+    }
+}

src/InternshipSystem.Core/Entity/Internship/Internship.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using FluentValidation;
 using InternshipSystem.Core.ValueObject;
 
 namespace InternshipSystem.Core.Entity.Internship
@@ -12,7 +13,6 @@ namespace InternshipSystem.Core.Entity.Internship
         public InternshipRegistration InternshipRegistration { get; set; }
         public Report Report { get; set; }
         public List<Document> Documentation { get; set; }
-
         public Edition Edition { get; set; }
         
         public float? Grade { get; set; }
@@ -27,14 +27,19 @@ namespace InternshipSystem.Core.Entity.Internship
             internship.Report = Report.Create();
             internship.Documentation = new List<Document>();
 
+            if (student.Semester != 6)
+            {
+                internship.AddNewDocument("", DocumentType.OutsideSemesterApproval);
+            }
+            
             return internship;
         }
 
         public void AddNewDocument(string description, DocumentType type)
         {
-            if (Documentation.Any(d => d.Type == type))
+            if (type != DocumentType.Other && Documentation.Any(d => d.Type == type))
             {
-                throw new ArgumentException("Internship already has a document of given type");                
+                return;
             }
             
             var document = new Document
@@ -47,12 +52,54 @@ namespace InternshipSystem.Core.Entity.Internship
             Documentation.Add(document);
         }
 
-        public void UpdateDocumentScan(long documentId, byte[] documentScan)
+        public void RemoveDocument(DocumentType documentType)
         {
-            var document = Documentation.First(d => d.Id == documentId);
+            if (documentType == DocumentType.Other)
+            {
+                return;
+            }
+            
+            var doc = Documentation.FirstOrDefault(d => d.Type == documentType);
 
-            // document.Scan = documentScan;
+            if (doc != null)
-            // document.State = DocumentState.Submitted;
+            { 
+                Documentation.Remove(doc);
+            }
+        }
+
+        public void RemoveDocument(long id)
+        {
+            var doc = Documentation.FirstOrDefault(d => d.Id == id);
+
+            if (doc != null)
+            { 
+                Documentation.Remove(doc);
+            }
+        }
+
+        public IEnumerable<ErrorDescription> ValidateStatus()
+        {
+            var validator = new Validator();
+
+            var result = validator.Validate(this);
+
+            return result.ToErrorDescription();
+        }
+
+        private class Validator : AbstractValidator<Internship>
+        {
+            public Validator()
+            {
+                RuleFor(i => i.Report)
+                    .Must(r => r.State == DocumentState.Accepted)
+                    .WithMessage("error.report.not_accepted");
+                RuleFor(i => i.InternshipRegistration)
+                    .Must(r => r.State == DocumentState.Accepted)
+                    .WithMessage("error.registration.not_accepted");
+                RuleForEach(i => i.Documentation)
+                    .Must(d => d.State == DocumentState.Accepted)
+                    .WithMessage("error.documentation.not_accepted");
+            }
         }
     }
 }

src/InternshipSystem.Core/Entity/Internship/InternshipRegistration.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Data;
 using System.Linq;
 using FluentValidation;
 using InternshipSystem.Core.UglyOrmArtifacts;
@@ -12,14 +11,15 @@ namespace InternshipSystem.Core.Entity.Internship
         public long Id { get; set; }
         public Company Company { get; set; }
         public BranchOffice BranchAddress { get; set; }
+        public DateTime SubmissionDate { get; set; }
         public DateTime Start { get; set; }
         public DateTime End { get; set; }
         public Mentor Mentor { get; set; }
         public List<ProgramSubject> Subjects { get; set; }
         public InternshipType Type { get; set; }
-
         public int DeclaredHours { get; set; }
         public DocumentState State { get; set; }
+        public string ChangeStateComment { get; set; }
 
         public static InternshipRegistration Create()
         {
@@ -27,7 +27,7 @@ namespace InternshipSystem.Core.Entity.Internship
         }
 
 
-        public (DocumentState State, IEnumerable<string>) ValidateStatus(Edition edition)
+        public (DocumentState State, IEnumerable<ErrorDescription>) ValidateStatus(Edition edition)
         {
             var validator = new Validator(edition);
 
@@ -35,7 +35,9 @@ namespace InternshipSystem.Core.Entity.Internship
 
             State = result.IsValid ? DocumentState.Submitted : DocumentState.Draft;
 
-            return (State, result.Errors.Select(failure => failure.ToString()));
+            SubmissionDate = DocumentState.Submitted.Equals(State) ? DateTime.UtcNow.AddHours(1) : SubmissionDate;
+
+            return (State, result.ToErrorDescription());
         }
 
         public class Validator : AbstractValidator<InternshipRegistration>
@@ -60,13 +62,9 @@ namespace InternshipSystem.Core.Entity.Internship
                     .Must(edition.IsTypeAvailable)
                     .WithMessage("error.type.not_available");
                 RuleFor(x => x.Start)
-                    .GreaterThanOrEqualTo(edition.EditionStart)
-                    .LessThan(x => x.End)
                     .NotEmpty()
                     .WithMessage("error.start_date.empty");
                 RuleFor(x => x.End)
-                    .LessThanOrEqualTo(edition.EditionFinish)
-                    .GreaterThan(x => x.Start)
                     .NotEmpty()
                     .WithMessage("error.end_date.empty");
                 RuleFor(x => x.DeclaredHours)
@@ -75,4 +73,10 @@ namespace InternshipSystem.Core.Entity.Internship
             }
         }
     }
+
+    public class ErrorDescription
+    {
+        public string Key { get; set; }
+        public Dictionary<string, object> Parameters { get; set; }
+    }
 }

src/InternshipSystem.Core/Entity/Internship/InternshipType.cs

@@ -7,5 +7,7 @@
         public string LabelEng { get; set; }
         public string Description { get; set; }
         public string DescriptionEng { get; set; }
+        public bool RequireDeansApproval { get; set; }
+        public bool RequireInsurance { get; set; }
     }
 }

src/InternshipSystem.Core/Entity/Report.cs

@@ -6,12 +6,17 @@ namespace InternshipSystem.Core
     {
         public long Id { get; set; }
         public DocumentState State { get; set; }
-        public RangeOfActivity Range { get; set; }
+        public string Value { get; set; }
-        public Uri SiteAddress { get; set; }
 
         public static Report Create()
         {
             return new Report();
         }
+
+        public void UpdateReport(string reportValue)
+        {
+            Value = reportValue;
+            State = DocumentState.Submitted;
+        }
     }
 }

src/InternshipSystem.Core/Entity/ReportField.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Generic;
+
+namespace InternshipSystem.Core.Entity
+{
+    public class ReportField
+    {
+        public ReportField()
+        {
+            
+        }
+        
+        public ReportField(string label, string labelEng, string description, string descriptionEng, FieldType fieldType)
+        {
+            Label = label;
+            LabelEng = labelEng;
+            Description = description;
+            DescriptionEng = descriptionEng;
+            FieldType = fieldType;
+        }
+
+        public long Id { get; set; }
+        public string Label { get; set; }
+        public string LabelEng { get; set; }
+        public string Description { get; set; }
+        public string DescriptionEng { get; set; }
+        public FieldType FieldType { get; set; }
+    }
+
+    public enum FieldType
+    {
+        LongText,
+        ShortText,
+        Select,
+        Radial,
+        Checkbox
+    }
+
+    public class ReportChoiceField : ReportField
+    {
+        public ReportChoiceField(string label, string labelEng, string description, string descriptionEng,
+            FieldType fieldType, string[] choices) : base(label, labelEng, description, descriptionEng, fieldType)
+        {
+            Choices = choices;
+        }
+        
+        public string[] Choices { get; set; }
+    }
+}

src/InternshipSystem.Core/UglyOrmArtifacts/ReportFieldEdition.cs

@@ -0,0 +1,13 @@
+using System;
+using InternshipSystem.Core.Entity;
+
+namespace InternshipSystem.Core.UglyOrmArtifacts
+{
+    public class ReportFieldEdition
+    {
+        public Guid EditionId { get; set; }
+        public Edition Edition { get; set; }
+        public long ReportFieldId { get; set; }
+        public ReportField Field { get; set; }
+    }
+}

src/InternshipSystem.Core/ValueObject/DocumentType.cs

@@ -3,7 +3,11 @@
     public enum DocumentType
     {
         IppScan,
-        DeanConsent,
+        OutsideTermApproval,
-        NnwIsurance
+        InternshipTypeApproval,
+        OutsideSemesterApproval,
+        NnwInsurance,
+        InternshipEvaluation,
+        Other
     }
 }

src/InternshipSystem.Repository/DatabaseFiller.cs

@@ -3,8 +3,10 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
 using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
 using InternshipSystem.Core.Entity.Internship;
 using InternshipSystem.Core.UglyOrmArtifacts;
+using InternshipSystem.Core.ValueObject;
 using Microsoft.EntityFrameworkCore;
 
 namespace InternshipSystem.Repository
@@ -118,6 +120,7 @@ namespace InternshipSystem.Repository
                     LabelEng = "Internship agreement",
                     Description = "Praktyka bezpłatna",
                     DescriptionEng = "Free internship",
+                    RequireInsurance = true
                 },
                 new InternshipType
                 {
@@ -128,6 +131,7 @@ namespace InternshipSystem.Repository
                 {
                     Label = "Umowa o staż bezpłatny",
                     LabelEng = "Free apprenticeship agreement",
+                    RequireInsurance = true
                 },
                 new InternshipType
                 {
@@ -157,6 +161,7 @@ namespace InternshipSystem.Repository
                 {
                     Label = "Umowa zlecenia (w tym B2B)",
                     LabelEng = "Contract of mandate (including B2B)",
+                    RequireDeansApproval = true
                 },  
             };
             await Context.InternshipTypes.AddRangeAsync(internshipTypes);
@@ -203,6 +208,7 @@ namespace InternshipSystem.Repository
                     Course = new Course
                     {
                         Name = "Informatyka",
+                        NameEng = "Informatics",
                     },
                     AvailableInternshipTypes = new List<EditionInternshipType>
                     {
@@ -261,6 +267,7 @@ namespace InternshipSystem.Repository
                     Course = new Course
                     {
                         Name = "Inżynieria Biomedyczna",
+                        NameEng = "Biomedical Engineering",
                     },
                     AvailableInternshipTypes = new List<EditionInternshipType>
                     {
@@ -291,6 +298,14 @@ namespace InternshipSystem.Repository
                 {
                     new Internship
                     {
+                        Documentation = new List<Document>
+                        {
+                            new Document
+                            {
+                                Description = "doc",
+                                Type = DocumentType.IppScan
+                            }  
+                        },
                         Student = new Student
                         {
                             FirstName = "Jan",
@@ -302,6 +317,7 @@ namespace InternshipSystem.Repository
                         {
                             Company = Context.Companies.First(c => c.Name.Equals("Intel")),
                             Type = Context.InternshipTypes.First(t => t.Label.Equals("Umowa o pracę")),
+                            SubmissionDate = new DateTime(2000, 6, 2),
                             Start = new DateTime(2000, 7, 1),
                             End = new DateTime(2000, 8, 30),
                             State = DocumentState.Submitted,
@@ -334,6 +350,7 @@ namespace InternshipSystem.Repository
                                 }
                             }
                         },
+                        Report = Report.Create()
                     },
                     new Internship
                     {
@@ -348,6 +365,7 @@ namespace InternshipSystem.Repository
                         {
                             Company = Context.Companies.First(c => c.Name.Equals("Asseco Poland")),
                             Type =  Context.InternshipTypes.First(t => t.Label.Equals("Umowa zlecenia (w tym B2B)")),
+                            SubmissionDate = new DateTime(2000, 6, 1),
                             Start = new DateTime(2000, 7, 1),
                             End = new DateTime(2000, 8, 30),
                             State = DocumentState.Submitted,

src/InternshipSystem.Repository/InternshipDbContext.cs

@@ -1,5 +1,8 @@
+using System;
+using System.Linq;
 using Microsoft.EntityFrameworkCore;
 using InternshipSystem.Core;
+using InternshipSystem.Core.Entity;
 using InternshipSystem.Core.Entity.Internship;
 using InternshipSystem.Core.UglyOrmArtifacts;
 
@@ -12,6 +15,10 @@ namespace InternshipSystem.Repository
         public DbSet<StaticPage> StaticPages { get; set; }
         public DbSet<InternshipType> InternshipTypes { get; set; }
         public DbSet<Student> Students { get; set; }
+        public DbSet<Course> Courses { get; set; }
+        public DbSet<Internship> Internships { get; set; }
+
+        public DbSet<ReportField> ReportFields { get; set; }
 
         public InternshipDbContext(DbContextOptions<InternshipDbContext> options)
             : base(options)
@@ -88,6 +95,37 @@ namespace InternshipSystem.Repository
                     .WithMany()
                     .HasForeignKey(subject => subject.InternshipSubjectId);
             });
+
+            modelBuilder.Entity<ReportFieldEdition>(builder =>
+            {
+                builder
+                    .HasKey(e => new {e.EditionId, e.ReportFieldId});
+
+                builder
+                    .HasOne(e => e.Edition)
+                    .WithMany(edition => edition.ReportSchema)
+                    .HasForeignKey(r => r.EditionId);
+
+                builder
+                    .HasOne(e => e.Field)
+                    .WithMany()
+                    .HasForeignKey(r => r.ReportFieldId);
+            });
+
+            modelBuilder.Entity<ReportField>()
+                .HasDiscriminator<string>("field_discrimnator")
+                .HasValue<ReportField>("single")
+                .HasValue<ReportChoiceField>("choice");
+
+            modelBuilder.Entity<ReportChoiceField>()
+                .Property(r => r.Choices)
+                .HasConversion(
+                    a => string.Join('#', a),
+                    s => s.Split('#', StringSplitOptions.RemoveEmptyEntries));
+
+            modelBuilder.Entity<Report>()
+                .Property(r => r.Value)
+                .HasColumnType("jsonb");
         }
     }
 }

src/InternshipSystem.Repository/Migrations/20210110210810_Init.Designer.cs

@@ -10,7 +10,7 @@ using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
 namespace InternshipSystem.Repository.Migrations
 {
     [DbContext(typeof(InternshipDbContext))]
-    [Migration("20201025211622_Init")]
+    [Migration("20210110210810_Init")]
     partial class Init
     {
         protected override void BuildTargetModel(ModelBuilder modelBuilder)
@@ -72,24 +72,6 @@ namespace InternshipSystem.Repository.Migrations
                     b.ToTable("companies");
                 });
 
-            modelBuilder.Entity("InternshipSystem.Core.Course", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnName("id")
-                        .HasColumnType("bigint")
-                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
-
-                    b.Property<string>("Name")
-                        .HasColumnName("name")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id")
-                        .HasName("pk_course");
-
-                    b.ToTable("course");
-                });
-
             modelBuilder.Entity("InternshipSystem.Core.Document", b =>
                 {
                     b.Property<long>("Id")
@@ -98,6 +80,10 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnType("bigint")
                         .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
 
+                    b.Property<string>("ChangeStateComment")
+                        .HasColumnName("change_state_comment")
+                        .HasColumnType("text");
+
                     b.Property<string>("Description")
                         .HasColumnName("description")
                         .HasColumnType("text");
@@ -106,10 +92,6 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("internship_id")
                         .HasColumnType("bigint");
 
-                    b.Property<string>("RejectionReason")
-                        .HasColumnName("rejection_reason")
-                        .HasColumnType("text");
-
                     b.Property<int>("State")
                         .HasColumnName("state")
                         .HasColumnType("integer");
@@ -187,6 +169,28 @@ namespace InternshipSystem.Repository.Migrations
                     b.ToTable("editions");
                 });
 
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Course", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnName("name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameEng")
+                        .HasColumnName("name_eng")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_courses");
+
+                    b.ToTable("courses");
+                });
+
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.Internship", b =>
                 {
                     b.Property<long>("Id")
@@ -216,21 +220,21 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnType("bigint");
 
                     b.HasKey("Id")
-                        .HasName("pk_internship");
+                        .HasName("pk_internships");
 
                     b.HasIndex("EditionId")
-                        .HasName("ix_internship_edition_id");
+                        .HasName("ix_internships_edition_id");
 
                     b.HasIndex("InternshipRegistrationId")
-                        .HasName("ix_internship_internship_registration_id");
+                        .HasName("ix_internships_internship_registration_id");
 
                     b.HasIndex("ReportId")
-                        .HasName("ix_internship_report_id");
+                        .HasName("ix_internships_report_id");
 
                     b.HasIndex("StudentId")
-                        .HasName("ix_internship_student_id");
+                        .HasName("ix_internships_student_id");
 
-                    b.ToTable("internship");
+                    b.ToTable("internships");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipRegistration", b =>
@@ -245,6 +249,10 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("branch_address_id")
                         .HasColumnType("bigint");
 
+                    b.Property<string>("ChangeStateComment")
+                        .HasColumnName("change_state_comment")
+                        .HasColumnType("text");
+
                     b.Property<long?>("CompanyId")
                         .HasColumnName("company_id")
                         .HasColumnType("bigint");
@@ -265,6 +273,10 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("state")
                         .HasColumnType("integer");
 
+                    b.Property<DateTime>("SubmissionDate")
+                        .HasColumnName("submission_date")
+                        .HasColumnType("timestamp without time zone");
+
                     b.Property<long?>("TypeId")
                         .HasColumnName("type_id")
                         .HasColumnType("bigint");
@@ -330,12 +342,57 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("label_eng")
                         .HasColumnType("text");
 
+                    b.Property<bool>("RequireDeansApproval")
+                        .HasColumnName("require_deans_approval")
+                        .HasColumnType("boolean");
+
                     b.HasKey("Id")
                         .HasName("pk_internship_types");
 
                     b.ToTable("internship_types");
                 });
 
+            modelBuilder.Entity("InternshipSystem.Core.Entity.ReportField", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Description")
+                        .HasColumnName("description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionEng")
+                        .HasColumnName("description_eng")
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldType")
+                        .HasColumnName("field_type")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Label")
+                        .HasColumnName("label")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LabelEng")
+                        .HasColumnName("label_eng")
+                        .HasColumnType("text");
+
+                    b.Property<string>("field_discrimnator")
+                        .IsRequired()
+                        .HasColumnName("field_discrimnator")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_report_fields");
+
+                    b.ToTable("report_fields");
+
+                    b.HasDiscriminator<string>("field_discrimnator").HasValue("single");
+                });
+
             modelBuilder.Entity("InternshipSystem.Core.Report", b =>
                 {
                     b.Property<long>("Id")
@@ -344,18 +401,14 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnType("bigint")
                         .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
 
-                    b.Property<int>("Range")
-                        .HasColumnName("range")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("SiteAddress")
-                        .HasColumnName("site_address")
-                        .HasColumnType("text");
-
                     b.Property<int>("State")
                         .HasColumnName("state")
                         .HasColumnType("integer");
 
+                    b.Property<string>("Value")
+                        .HasColumnName("value")
+                        .HasColumnType("jsonb");
+
                     b.HasKey("Id")
                         .HasName("pk_report");
 
@@ -491,6 +544,36 @@ namespace InternshipSystem.Repository.Migrations
                     b.ToTable("program_subject");
                 });
 
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ReportFieldEdition", b =>
+                {
+                    b.Property<Guid>("EditionId")
+                        .HasColumnName("edition_id")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("ReportFieldId")
+                        .HasColumnName("report_field_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("EditionId", "ReportFieldId")
+                        .HasName("pk_report_field_edition");
+
+                    b.HasIndex("ReportFieldId")
+                        .HasName("ix_report_field_edition_report_field_id");
+
+                    b.ToTable("report_field_edition");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.ReportChoiceField", b =>
+                {
+                    b.HasBaseType("InternshipSystem.Core.Entity.ReportField");
+
+                    b.Property<string>("Choices")
+                        .HasColumnName("choices")
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue("choice");
+                });
+
             modelBuilder.Entity("InternshipSystem.Core.BranchOffice", b =>
                 {
                     b.HasOne("InternshipSystem.Core.Company", null)
@@ -542,7 +625,7 @@ namespace InternshipSystem.Repository.Migrations
                     b.HasOne("InternshipSystem.Core.Entity.Internship.Internship", null)
                         .WithMany("Documentation")
                         .HasForeignKey("InternshipId")
-                        .HasConstraintName("fk_document_internship_internship_id");
+                        .HasConstraintName("fk_document_internships_internship_id");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.DocumentScan", b =>
@@ -557,10 +640,10 @@ namespace InternshipSystem.Repository.Migrations
 
             modelBuilder.Entity("InternshipSystem.Core.Edition", b =>
                 {
-                    b.HasOne("InternshipSystem.Core.Course", "Course")
+                    b.HasOne("InternshipSystem.Core.Entity.Course", "Course")
                         .WithMany()
                         .HasForeignKey("CourseId")
-                        .HasConstraintName("fk_editions_course_course_id");
+                        .HasConstraintName("fk_editions_courses_course_id");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.Internship", b =>
@@ -568,22 +651,22 @@ namespace InternshipSystem.Repository.Migrations
                     b.HasOne("InternshipSystem.Core.Edition", "Edition")
                         .WithMany("Internships")
                         .HasForeignKey("EditionId")
-                        .HasConstraintName("fk_internship_editions_edition_id");
+                        .HasConstraintName("fk_internships_editions_edition_id");
 
                     b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipRegistration", "InternshipRegistration")
                         .WithMany()
                         .HasForeignKey("InternshipRegistrationId")
-                        .HasConstraintName("fk_internship_internship_registration_internship_registration_");
+                        .HasConstraintName("fk_internships_internship_registration_internship_registration");
 
                     b.HasOne("InternshipSystem.Core.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
-                        .HasConstraintName("fk_internship_report_report_id");
+                        .HasConstraintName("fk_internships_report_report_id");
 
                     b.HasOne("InternshipSystem.Core.Student", "Student")
                         .WithMany()
                         .HasForeignKey("StudentId")
-                        .HasConstraintName("fk_internship_students_student_id");
+                        .HasConstraintName("fk_internships_students_student_id");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipRegistration", b =>
@@ -688,6 +771,23 @@ namespace InternshipSystem.Repository.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
                 });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ReportFieldEdition", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Edition", "Edition")
+                        .WithMany("ReportSchema")
+                        .HasForeignKey("EditionId")
+                        .HasConstraintName("fk_report_field_edition_editions_edition_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("InternshipSystem.Core.Entity.ReportField", "Field")
+                        .WithMany()
+                        .HasForeignKey("ReportFieldId")
+                        .HasConstraintName("fk_report_field_edition_report_fields_report_field_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
 #pragma warning restore 612, 618
         }
     }

src/InternshipSystem.Repository/Migrations/20210110210810_Init.cs

@@ -24,16 +24,17 @@ namespace InternshipSystem.Repository.Migrations
                 });
 
             migrationBuilder.CreateTable(
-                name: "course",
+                name: "courses",
                 columns: table => new
                 {
                     id = table.Column<long>(nullable: false)
                         .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    name = table.Column<string>(nullable: true)
+                    name = table.Column<string>(nullable: true),
+                    name_eng = table.Column<string>(nullable: true)
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("pk_course", x => x.id);
+                    table.PrimaryKey("pk_courses", x => x.id);
                 });
 
             migrationBuilder.CreateTable(
@@ -59,7 +60,8 @@ namespace InternshipSystem.Repository.Migrations
                     label = table.Column<string>(nullable: true),
                     label_eng = table.Column<string>(nullable: true),
                     description = table.Column<string>(nullable: true),
-                    description_eng = table.Column<string>(nullable: true)
+                    description_eng = table.Column<string>(nullable: true),
+                    require_deans_approval = table.Column<bool>(nullable: false)
                 },
                 constraints: table =>
                 {
@@ -73,14 +75,32 @@ namespace InternshipSystem.Repository.Migrations
                     id = table.Column<long>(nullable: false)
                         .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
                     state = table.Column<int>(nullable: false),
-                    range = table.Column<int>(nullable: false),
+                    value = table.Column<string>(type: "jsonb", nullable: true)
-                    site_address = table.Column<string>(nullable: true)
                 },
                 constraints: table =>
                 {
                     table.PrimaryKey("pk_report", x => x.id);
                 });
 
+            migrationBuilder.CreateTable(
+                name: "report_fields",
+                columns: table => new
+                {
+                    id = table.Column<long>(nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    label = table.Column<string>(nullable: true),
+                    label_eng = table.Column<string>(nullable: true),
+                    description = table.Column<string>(nullable: true),
+                    description_eng = table.Column<string>(nullable: true),
+                    field_type = table.Column<int>(nullable: false),
+                    field_discrimnator = table.Column<string>(nullable: false),
+                    choices = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_report_fields", x => x.id);
+                });
+
             migrationBuilder.CreateTable(
                 name: "static_pages",
                 columns: table => new
@@ -155,9 +175,9 @@ namespace InternshipSystem.Repository.Migrations
                 {
                     table.PrimaryKey("pk_editions", x => x.id);
                     table.ForeignKey(
-                        name: "fk_editions_course_course_id",
+                        name: "fk_editions_courses_course_id",
                         column: x => x.course_id,
-                        principalTable: "course",
+                        principalTable: "courses",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Restrict);
                 });
@@ -170,6 +190,7 @@ namespace InternshipSystem.Repository.Migrations
                         .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
                     company_id = table.Column<long>(nullable: true),
                     branch_address_id = table.Column<long>(nullable: true),
+                    submission_date = table.Column<DateTime>(nullable: false),
                     start = table.Column<DateTime>(nullable: false),
                     end = table.Column<DateTime>(nullable: false),
                     first_name = table.Column<string>(nullable: true),
@@ -178,7 +199,8 @@ namespace InternshipSystem.Repository.Migrations
                     phone_number = table.Column<string>(nullable: true),
                     type_id = table.Column<long>(nullable: true),
                     declared_hours = table.Column<int>(nullable: false),
-                    state = table.Column<int>(nullable: false)
+                    state = table.Column<int>(nullable: false),
+                    change_state_comment = table.Column<string>(nullable: true)
                 },
                 constraints: table =>
                 {
@@ -252,7 +274,31 @@ namespace InternshipSystem.Repository.Migrations
                 });
 
             migrationBuilder.CreateTable(
-                name: "internship",
+                name: "report_field_edition",
+                columns: table => new
+                {
+                    edition_id = table.Column<Guid>(nullable: false),
+                    report_field_id = table.Column<long>(nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("pk_report_field_edition", x => new { x.edition_id, x.report_field_id });
+                    table.ForeignKey(
+                        name: "fk_report_field_edition_editions_edition_id",
+                        column: x => x.edition_id,
+                        principalTable: "editions",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "fk_report_field_edition_report_fields_report_field_id",
+                        column: x => x.report_field_id,
+                        principalTable: "report_fields",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "internships",
                 columns: table => new
                 {
                     id = table.Column<long>(nullable: false)
@@ -265,27 +311,27 @@ namespace InternshipSystem.Repository.Migrations
                 },
                 constraints: table =>
                 {
-                    table.PrimaryKey("pk_internship", x => x.id);
+                    table.PrimaryKey("pk_internships", x => x.id);
                     table.ForeignKey(
-                        name: "fk_internship_editions_edition_id",
+                        name: "fk_internships_editions_edition_id",
                         column: x => x.edition_id,
                         principalTable: "editions",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Restrict);
                     table.ForeignKey(
-                        name: "fk_internship_internship_registration_internship_registration_",
+                        name: "fk_internships_internship_registration_internship_registration",
                         column: x => x.internship_registration_id,
                         principalTable: "internship_registration",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Restrict);
                     table.ForeignKey(
-                        name: "fk_internship_report_report_id",
+                        name: "fk_internships_report_report_id",
                         column: x => x.report_id,
                         principalTable: "report",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Restrict);
                     table.ForeignKey(
-                        name: "fk_internship_students_student_id",
+                        name: "fk_internships_students_student_id",
                         column: x => x.student_id,
                         principalTable: "students",
                         principalColumn: "id",
@@ -325,16 +371,16 @@ namespace InternshipSystem.Repository.Migrations
                     description = table.Column<string>(nullable: true),
                     type = table.Column<int>(nullable: false),
                     state = table.Column<int>(nullable: false),
-                    rejection_reason = table.Column<string>(nullable: true),
+                    change_state_comment = table.Column<string>(nullable: true),
                     internship_id = table.Column<long>(nullable: true)
                 },
                 constraints: table =>
                 {
                     table.PrimaryKey("pk_document", x => x.id);
                     table.ForeignKey(
-                        name: "fk_document_internship_internship_id",
+                        name: "fk_document_internships_internship_id",
                         column: x => x.internship_id,
-                        principalTable: "internship",
+                        principalTable: "internships",
                         principalColumn: "id",
                         onDelete: ReferentialAction.Restrict);
                 });
@@ -385,26 +431,6 @@ namespace InternshipSystem.Repository.Migrations
                 table: "editions",
                 column: "course_id");
 
-            migrationBuilder.CreateIndex(
-                name: "ix_internship_edition_id",
-                table: "internship",
-                column: "edition_id");
-
-            migrationBuilder.CreateIndex(
-                name: "ix_internship_internship_registration_id",
-                table: "internship",
-                column: "internship_registration_id");
-
-            migrationBuilder.CreateIndex(
-                name: "ix_internship_report_id",
-                table: "internship",
-                column: "report_id");
-
-            migrationBuilder.CreateIndex(
-                name: "ix_internship_student_id",
-                table: "internship",
-                column: "student_id");
-
             migrationBuilder.CreateIndex(
                 name: "ix_internship_registration_branch_address_id",
                 table: "internship_registration",
@@ -420,10 +446,35 @@ namespace InternshipSystem.Repository.Migrations
                 table: "internship_registration",
                 column: "type_id");
 
+            migrationBuilder.CreateIndex(
+                name: "ix_internships_edition_id",
+                table: "internships",
+                column: "edition_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_internships_internship_registration_id",
+                table: "internships",
+                column: "internship_registration_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_internships_report_id",
+                table: "internships",
+                column: "report_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_internships_student_id",
+                table: "internships",
+                column: "student_id");
+
             migrationBuilder.CreateIndex(
                 name: "ix_program_subject_internship_subject_id",
                 table: "program_subject",
                 column: "internship_subject_id");
+
+            migrationBuilder.CreateIndex(
+                name: "ix_report_field_edition_report_field_id",
+                table: "report_field_edition",
+                column: "report_field_id");
         }
 
         protected override void Down(MigrationBuilder migrationBuilder)
@@ -440,6 +491,9 @@ namespace InternshipSystem.Repository.Migrations
             migrationBuilder.DropTable(
                 name: "program_subject");
 
+            migrationBuilder.DropTable(
+                name: "report_field_edition");
+
             migrationBuilder.DropTable(
                 name: "static_pages");
 
@@ -450,7 +504,10 @@ namespace InternshipSystem.Repository.Migrations
                 name: "internship_subject");
 
             migrationBuilder.DropTable(
-                name: "internship");
+                name: "report_fields");
+
+            migrationBuilder.DropTable(
+                name: "internships");
 
             migrationBuilder.DropTable(
                 name: "editions");
@@ -465,7 +522,7 @@ namespace InternshipSystem.Repository.Migrations
                 name: "students");
 
             migrationBuilder.DropTable(
-                name: "course");
+                name: "courses");
 
             migrationBuilder.DropTable(
                 name: "branch_office");

src/InternshipSystem.Repository/Migrations/20210111195519_Insurance.Designer.cs

@@ -0,0 +1,798 @@
+// <auto-generated />
+using System;
+using InternshipSystem.Repository;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace InternshipSystem.Repository.Migrations
+{
+    [DbContext(typeof(InternshipDbContext))]
+    [Migration("20210111195519_Insurance")]
+    partial class Insurance
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn)
+                .HasAnnotation("ProductVersion", "3.1.4")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            modelBuilder.Entity("InternshipSystem.Core.BranchOffice", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<long?>("CompanyId")
+                        .HasColumnName("company_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("Provider")
+                        .HasColumnName("provider")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id")
+                        .HasName("pk_branch_office");
+
+                    b.HasIndex("CompanyId")
+                        .HasName("ix_branch_office_company_id");
+
+                    b.ToTable("branch_office");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Company", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnName("name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Nip")
+                        .HasColumnName("nip")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Provider")
+                        .HasColumnName("provider")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id")
+                        .HasName("pk_companies");
+
+                    b.ToTable("companies");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Document", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("ChangeStateComment")
+                        .HasColumnName("change_state_comment")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnName("description")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("InternshipId")
+                        .HasColumnName("internship_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("State")
+                        .HasColumnName("state")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Type")
+                        .HasColumnName("type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id")
+                        .HasName("pk_document");
+
+                    b.HasIndex("InternshipId")
+                        .HasName("ix_document_internship_id");
+
+                    b.ToTable("document");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.DocumentScan", b =>
+                {
+                    b.Property<long>("DocumentId")
+                        .HasColumnName("document_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<byte[]>("File")
+                        .HasColumnName("file")
+                        .HasColumnType("bytea");
+
+                    b.Property<string>("Filename")
+                        .HasColumnName("filename")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Mime")
+                        .HasColumnName("mime")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Size")
+                        .HasColumnName("size")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("DocumentId")
+                        .HasName("pk_document_scan");
+
+                    b.ToTable("document_scan");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Edition", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("uuid");
+
+                    b.Property<long?>("CourseId")
+                        .HasColumnName("course_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<DateTime>("EditionFinish")
+                        .HasColumnName("edition_finish")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime>("EditionStart")
+                        .HasColumnName("edition_start")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime>("ReportingStart")
+                        .HasColumnName("reporting_start")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.HasKey("Id")
+                        .HasName("pk_editions");
+
+                    b.HasIndex("CourseId")
+                        .HasName("ix_editions_course_id");
+
+                    b.ToTable("editions");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Course", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnName("name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameEng")
+                        .HasColumnName("name_eng")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_courses");
+
+                    b.ToTable("courses");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.Internship", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<Guid?>("EditionId")
+                        .HasColumnName("edition_id")
+                        .HasColumnType("uuid");
+
+                    b.Property<float?>("Grade")
+                        .HasColumnName("grade")
+                        .HasColumnType("real");
+
+                    b.Property<long?>("InternshipRegistrationId")
+                        .HasColumnName("internship_registration_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("ReportId")
+                        .HasColumnName("report_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("StudentId")
+                        .HasColumnName("student_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id")
+                        .HasName("pk_internships");
+
+                    b.HasIndex("EditionId")
+                        .HasName("ix_internships_edition_id");
+
+                    b.HasIndex("InternshipRegistrationId")
+                        .HasName("ix_internships_internship_registration_id");
+
+                    b.HasIndex("ReportId")
+                        .HasName("ix_internships_report_id");
+
+                    b.HasIndex("StudentId")
+                        .HasName("ix_internships_student_id");
+
+                    b.ToTable("internships");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipRegistration", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<long?>("BranchAddressId")
+                        .HasColumnName("branch_address_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ChangeStateComment")
+                        .HasColumnName("change_state_comment")
+                        .HasColumnType("text");
+
+                    b.Property<long?>("CompanyId")
+                        .HasColumnName("company_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("DeclaredHours")
+                        .HasColumnName("declared_hours")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("End")
+                        .HasColumnName("end")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<DateTime>("Start")
+                        .HasColumnName("start")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<int>("State")
+                        .HasColumnName("state")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("SubmissionDate")
+                        .HasColumnName("submission_date")
+                        .HasColumnType("timestamp without time zone");
+
+                    b.Property<long?>("TypeId")
+                        .HasColumnName("type_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id")
+                        .HasName("pk_internship_registration");
+
+                    b.HasIndex("BranchAddressId")
+                        .HasName("ix_internship_registration_branch_address_id");
+
+                    b.HasIndex("CompanyId")
+                        .HasName("ix_internship_registration_company_id");
+
+                    b.HasIndex("TypeId")
+                        .HasName("ix_internship_registration_type_id");
+
+                    b.ToTable("internship_registration");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipSubject", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Description")
+                        .HasColumnName("description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionEng")
+                        .HasColumnName("description_eng")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_internship_subject");
+
+                    b.ToTable("internship_subject");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipType", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Description")
+                        .HasColumnName("description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionEng")
+                        .HasColumnName("description_eng")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Label")
+                        .HasColumnName("label")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LabelEng")
+                        .HasColumnName("label_eng")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("RequireDeansApproval")
+                        .HasColumnName("require_deans_approval")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("RequireInsurance")
+                        .HasColumnName("require_insurance")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id")
+                        .HasName("pk_internship_types");
+
+                    b.ToTable("internship_types");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.ReportField", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Description")
+                        .HasColumnName("description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionEng")
+                        .HasColumnName("description_eng")
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldType")
+                        .HasColumnName("field_type")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Label")
+                        .HasColumnName("label")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LabelEng")
+                        .HasColumnName("label_eng")
+                        .HasColumnType("text");
+
+                    b.Property<string>("field_discrimnator")
+                        .IsRequired()
+                        .HasColumnName("field_discrimnator")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_report_fields");
+
+                    b.ToTable("report_fields");
+
+                    b.HasDiscriminator<string>("field_discrimnator").HasValue("single");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Report", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("State")
+                        .HasColumnName("state")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Value")
+                        .HasColumnName("value")
+                        .HasColumnType("jsonb");
+
+                    b.HasKey("Id")
+                        .HasName("pk_report");
+
+                    b.ToTable("report");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.StaticPage", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("AccessName")
+                        .HasColumnName("access_name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Content")
+                        .HasColumnName("content")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContentEng")
+                        .HasColumnName("content_eng")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnName("title")
+                        .HasColumnType("text");
+
+                    b.Property<string>("TitleEng")
+                        .HasColumnName("title_eng")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_static_pages");
+
+                    b.ToTable("static_pages");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Student", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<int>("AlbumNumber")
+                        .HasColumnName("album_number")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Course")
+                        .HasColumnName("course")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Email")
+                        .HasColumnName("email")
+                        .HasColumnType("text");
+
+                    b.Property<string>("FirstName")
+                        .HasColumnName("first_name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LastName")
+                        .HasColumnName("last_name")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("Semester")
+                        .HasColumnName("semester")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id")
+                        .HasName("pk_students");
+
+                    b.ToTable("students");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.EditionInternshipType", b =>
+                {
+                    b.Property<Guid>("EditionId")
+                        .HasColumnName("edition_id")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("InternshipTypeId")
+                        .HasColumnName("internship_type_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("EditionId", "InternshipTypeId")
+                        .HasName("pk_edition_internship_type");
+
+                    b.HasIndex("InternshipTypeId")
+                        .HasName("ix_edition_internship_type_internship_type_id");
+
+                    b.ToTable("edition_internship_type");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.EditionSubject", b =>
+                {
+                    b.Property<Guid>("EditionId")
+                        .HasColumnName("edition_id")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("InternshipSubjectId")
+                        .HasColumnName("internship_subject_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("EditionId", "InternshipSubjectId")
+                        .HasName("pk_edition_subject");
+
+                    b.HasIndex("InternshipSubjectId")
+                        .HasName("ix_edition_subject_internship_subject_id");
+
+                    b.ToTable("edition_subject");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ProgramSubject", b =>
+                {
+                    b.Property<long>("InternshipRegistrationId")
+                        .HasColumnName("internship_registration_id")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("InternshipSubjectId")
+                        .HasColumnName("internship_subject_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("InternshipRegistrationId", "InternshipSubjectId")
+                        .HasName("pk_program_subject");
+
+                    b.HasIndex("InternshipSubjectId")
+                        .HasName("ix_program_subject_internship_subject_id");
+
+                    b.ToTable("program_subject");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ReportFieldEdition", b =>
+                {
+                    b.Property<Guid>("EditionId")
+                        .HasColumnName("edition_id")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("ReportFieldId")
+                        .HasColumnName("report_field_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("EditionId", "ReportFieldId")
+                        .HasName("pk_report_field_edition");
+
+                    b.HasIndex("ReportFieldId")
+                        .HasName("ix_report_field_edition_report_field_id");
+
+                    b.ToTable("report_field_edition");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.ReportChoiceField", b =>
+                {
+                    b.HasBaseType("InternshipSystem.Core.Entity.ReportField");
+
+                    b.Property<string>("Choices")
+                        .HasColumnName("choices")
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue("choice");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.BranchOffice", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Company", null)
+                        .WithMany("Branches")
+                        .HasForeignKey("CompanyId")
+                        .HasConstraintName("fk_branch_office_companies_company_id");
+
+                    b.OwnsOne("InternshipSystem.Core.BranchAddress", "Address", b1 =>
+                        {
+                            b1.Property<long>("BranchOfficeId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnName("id")
+                                .HasColumnType("bigint")
+                                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                            b1.Property<string>("Building")
+                                .HasColumnName("building")
+                                .HasColumnType("text");
+
+                            b1.Property<string>("City")
+                                .HasColumnName("city")
+                                .HasColumnType("text");
+
+                            b1.Property<string>("Country")
+                                .HasColumnName("country")
+                                .HasColumnType("text");
+
+                            b1.Property<string>("PostalCode")
+                                .HasColumnName("postal_code")
+                                .HasColumnType("text");
+
+                            b1.Property<string>("Street")
+                                .HasColumnName("street")
+                                .HasColumnType("text");
+
+                            b1.HasKey("BranchOfficeId")
+                                .HasName("pk_branch_office");
+
+                            b1.ToTable("branch_office");
+
+                            b1.WithOwner()
+                                .HasForeignKey("BranchOfficeId")
+                                .HasConstraintName("fk_branch_address_branch_office_branch_office_id");
+                        });
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Document", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Entity.Internship.Internship", null)
+                        .WithMany("Documentation")
+                        .HasForeignKey("InternshipId")
+                        .HasConstraintName("fk_document_internships_internship_id");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.DocumentScan", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Document", "Document")
+                        .WithOne("Scan")
+                        .HasForeignKey("InternshipSystem.Core.DocumentScan", "DocumentId")
+                        .HasConstraintName("fk_document_scan_document_document_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Edition", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Entity.Course", "Course")
+                        .WithMany()
+                        .HasForeignKey("CourseId")
+                        .HasConstraintName("fk_editions_courses_course_id");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.Internship", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Edition", "Edition")
+                        .WithMany("Internships")
+                        .HasForeignKey("EditionId")
+                        .HasConstraintName("fk_internships_editions_edition_id");
+
+                    b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipRegistration", "InternshipRegistration")
+                        .WithMany()
+                        .HasForeignKey("InternshipRegistrationId")
+                        .HasConstraintName("fk_internships_internship_registration_internship_registration");
+
+                    b.HasOne("InternshipSystem.Core.Report", "Report")
+                        .WithMany()
+                        .HasForeignKey("ReportId")
+                        .HasConstraintName("fk_internships_report_report_id");
+
+                    b.HasOne("InternshipSystem.Core.Student", "Student")
+                        .WithMany()
+                        .HasForeignKey("StudentId")
+                        .HasConstraintName("fk_internships_students_student_id");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipRegistration", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.BranchOffice", "BranchAddress")
+                        .WithMany()
+                        .HasForeignKey("BranchAddressId")
+                        .HasConstraintName("fk_internship_registration_branch_office_branch_address_id");
+
+                    b.HasOne("InternshipSystem.Core.Company", "Company")
+                        .WithMany()
+                        .HasForeignKey("CompanyId")
+                        .HasConstraintName("fk_internship_registration_companies_company_id");
+
+                    b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipType", "Type")
+                        .WithMany()
+                        .HasForeignKey("TypeId")
+                        .HasConstraintName("fk_internship_registration_internship_types_type_id");
+
+                    b.OwnsOne("InternshipSystem.Core.Mentor", "Mentor", b1 =>
+                        {
+                            b1.Property<long>("InternshipRegistrationId")
+                                .ValueGeneratedOnAdd()
+                                .HasColumnName("id")
+                                .HasColumnType("bigint")
+                                .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                            b1.Property<string>("Email")
+                                .HasColumnName("email")
+                                .HasColumnType("text");
+
+                            b1.Property<string>("FirstName")
+                                .HasColumnName("first_name")
+                                .HasColumnType("text");
+
+                            b1.Property<string>("LastName")
+                                .HasColumnName("last_name")
+                                .HasColumnType("text");
+
+                            b1.Property<string>("PhoneNumber")
+                                .HasColumnName("phone_number")
+                                .HasColumnType("text");
+
+                            b1.HasKey("InternshipRegistrationId")
+                                .HasName("pk_internship_registration");
+
+                            b1.ToTable("internship_registration");
+
+                            b1.WithOwner()
+                                .HasForeignKey("InternshipRegistrationId")
+                                .HasConstraintName("fk_mentor_internship_registration_internship_registration_id");
+                        });
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.EditionInternshipType", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Edition", "Edition")
+                        .WithMany("AvailableInternshipTypes")
+                        .HasForeignKey("EditionId")
+                        .HasConstraintName("fk_edition_internship_type_editions_edition_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipType", "InternshipType")
+                        .WithMany()
+                        .HasForeignKey("InternshipTypeId")
+                        .HasConstraintName("fk_edition_internship_type_internship_types_internship_type_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.EditionSubject", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Edition", "Edition")
+                        .WithMany("AvailableSubjects")
+                        .HasForeignKey("EditionId")
+                        .HasConstraintName("fk_edition_subject_editions_edition_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipSubject", "Subject")
+                        .WithMany()
+                        .HasForeignKey("InternshipSubjectId")
+                        .HasConstraintName("fk_edition_subject_internship_subject_internship_subject_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ProgramSubject", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipRegistration", "Registration")
+                        .WithMany("Subjects")
+                        .HasForeignKey("InternshipRegistrationId")
+                        .HasConstraintName("fk_program_subject_internship_registration_internship_registrat")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipSubject", "Subject")
+                        .WithMany()
+                        .HasForeignKey("InternshipSubjectId")
+                        .HasConstraintName("fk_program_subject_internship_subject_internship_subject_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ReportFieldEdition", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Edition", "Edition")
+                        .WithMany("ReportSchema")
+                        .HasForeignKey("EditionId")
+                        .HasConstraintName("fk_report_field_edition_editions_edition_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("InternshipSystem.Core.Entity.ReportField", "Field")
+                        .WithMany()
+                        .HasForeignKey("ReportFieldId")
+                        .HasConstraintName("fk_report_field_edition_report_fields_report_field_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

src/InternshipSystem.Repository/Migrations/20210111195519_Insurance.cs

@@ -0,0 +1,23 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace InternshipSystem.Repository.Migrations
+{
+    public partial class Insurance : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "require_insurance",
+                table: "internship_types",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "require_insurance",
+                table: "internship_types");
+        }
+    }
+}

src/InternshipSystem.Repository/Migrations/InternshipDbContextModelSnapshot.cs

@@ -70,24 +70,6 @@ namespace InternshipSystem.Repository.Migrations
                     b.ToTable("companies");
                 });
 
-            modelBuilder.Entity("InternshipSystem.Core.Course", b =>
-                {
-                    b.Property<long>("Id")
-                        .ValueGeneratedOnAdd()
-                        .HasColumnName("id")
-                        .HasColumnType("bigint")
-                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
-
-                    b.Property<string>("Name")
-                        .HasColumnName("name")
-                        .HasColumnType("text");
-
-                    b.HasKey("Id")
-                        .HasName("pk_course");
-
-                    b.ToTable("course");
-                });
-
             modelBuilder.Entity("InternshipSystem.Core.Document", b =>
                 {
                     b.Property<long>("Id")
@@ -96,6 +78,10 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnType("bigint")
                         .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
 
+                    b.Property<string>("ChangeStateComment")
+                        .HasColumnName("change_state_comment")
+                        .HasColumnType("text");
+
                     b.Property<string>("Description")
                         .HasColumnName("description")
                         .HasColumnType("text");
@@ -104,10 +90,6 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("internship_id")
                         .HasColumnType("bigint");
 
-                    b.Property<string>("RejectionReason")
-                        .HasColumnName("rejection_reason")
-                        .HasColumnType("text");
-
                     b.Property<int>("State")
                         .HasColumnName("state")
                         .HasColumnType("integer");
@@ -185,6 +167,28 @@ namespace InternshipSystem.Repository.Migrations
                     b.ToTable("editions");
                 });
 
+            modelBuilder.Entity("InternshipSystem.Core.Entity.Course", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Name")
+                        .HasColumnName("name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("NameEng")
+                        .HasColumnName("name_eng")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_courses");
+
+                    b.ToTable("courses");
+                });
+
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.Internship", b =>
                 {
                     b.Property<long>("Id")
@@ -214,21 +218,21 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnType("bigint");
 
                     b.HasKey("Id")
-                        .HasName("pk_internship");
+                        .HasName("pk_internships");
 
                     b.HasIndex("EditionId")
-                        .HasName("ix_internship_edition_id");
+                        .HasName("ix_internships_edition_id");
 
                     b.HasIndex("InternshipRegistrationId")
-                        .HasName("ix_internship_internship_registration_id");
+                        .HasName("ix_internships_internship_registration_id");
 
                     b.HasIndex("ReportId")
-                        .HasName("ix_internship_report_id");
+                        .HasName("ix_internships_report_id");
 
                     b.HasIndex("StudentId")
-                        .HasName("ix_internship_student_id");
+                        .HasName("ix_internships_student_id");
 
-                    b.ToTable("internship");
+                    b.ToTable("internships");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipRegistration", b =>
@@ -243,6 +247,10 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("branch_address_id")
                         .HasColumnType("bigint");
 
+                    b.Property<string>("ChangeStateComment")
+                        .HasColumnName("change_state_comment")
+                        .HasColumnType("text");
+
                     b.Property<long?>("CompanyId")
                         .HasColumnName("company_id")
                         .HasColumnType("bigint");
@@ -263,6 +271,10 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("state")
                         .HasColumnType("integer");
 
+                    b.Property<DateTime>("SubmissionDate")
+                        .HasColumnName("submission_date")
+                        .HasColumnType("timestamp without time zone");
+
                     b.Property<long?>("TypeId")
                         .HasColumnName("type_id")
                         .HasColumnType("bigint");
@@ -328,12 +340,61 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnName("label_eng")
                         .HasColumnType("text");
 
+                    b.Property<bool>("RequireDeansApproval")
+                        .HasColumnName("require_deans_approval")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("RequireInsurance")
+                        .HasColumnName("require_insurance")
+                        .HasColumnType("boolean");
+
                     b.HasKey("Id")
                         .HasName("pk_internship_types");
 
                     b.ToTable("internship_types");
                 });
 
+            modelBuilder.Entity("InternshipSystem.Core.Entity.ReportField", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnName("id")
+                        .HasColumnType("bigint")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<string>("Description")
+                        .HasColumnName("description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DescriptionEng")
+                        .HasColumnName("description_eng")
+                        .HasColumnType("text");
+
+                    b.Property<int>("FieldType")
+                        .HasColumnName("field_type")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Label")
+                        .HasColumnName("label")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LabelEng")
+                        .HasColumnName("label_eng")
+                        .HasColumnType("text");
+
+                    b.Property<string>("field_discrimnator")
+                        .IsRequired()
+                        .HasColumnName("field_discrimnator")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id")
+                        .HasName("pk_report_fields");
+
+                    b.ToTable("report_fields");
+
+                    b.HasDiscriminator<string>("field_discrimnator").HasValue("single");
+                });
+
             modelBuilder.Entity("InternshipSystem.Core.Report", b =>
                 {
                     b.Property<long>("Id")
@@ -342,18 +403,14 @@ namespace InternshipSystem.Repository.Migrations
                         .HasColumnType("bigint")
                         .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
 
-                    b.Property<int>("Range")
-                        .HasColumnName("range")
-                        .HasColumnType("integer");
-
-                    b.Property<string>("SiteAddress")
-                        .HasColumnName("site_address")
-                        .HasColumnType("text");
-
                     b.Property<int>("State")
                         .HasColumnName("state")
                         .HasColumnType("integer");
 
+                    b.Property<string>("Value")
+                        .HasColumnName("value")
+                        .HasColumnType("jsonb");
+
                     b.HasKey("Id")
                         .HasName("pk_report");
 
@@ -489,6 +546,36 @@ namespace InternshipSystem.Repository.Migrations
                     b.ToTable("program_subject");
                 });
 
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ReportFieldEdition", b =>
+                {
+                    b.Property<Guid>("EditionId")
+                        .HasColumnName("edition_id")
+                        .HasColumnType("uuid");
+
+                    b.Property<long>("ReportFieldId")
+                        .HasColumnName("report_field_id")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("EditionId", "ReportFieldId")
+                        .HasName("pk_report_field_edition");
+
+                    b.HasIndex("ReportFieldId")
+                        .HasName("ix_report_field_edition_report_field_id");
+
+                    b.ToTable("report_field_edition");
+                });
+
+            modelBuilder.Entity("InternshipSystem.Core.Entity.ReportChoiceField", b =>
+                {
+                    b.HasBaseType("InternshipSystem.Core.Entity.ReportField");
+
+                    b.Property<string>("Choices")
+                        .HasColumnName("choices")
+                        .HasColumnType("text");
+
+                    b.HasDiscriminator().HasValue("choice");
+                });
+
             modelBuilder.Entity("InternshipSystem.Core.BranchOffice", b =>
                 {
                     b.HasOne("InternshipSystem.Core.Company", null)
@@ -540,7 +627,7 @@ namespace InternshipSystem.Repository.Migrations
                     b.HasOne("InternshipSystem.Core.Entity.Internship.Internship", null)
                         .WithMany("Documentation")
                         .HasForeignKey("InternshipId")
-                        .HasConstraintName("fk_document_internship_internship_id");
+                        .HasConstraintName("fk_document_internships_internship_id");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.DocumentScan", b =>
@@ -555,10 +642,10 @@ namespace InternshipSystem.Repository.Migrations
 
             modelBuilder.Entity("InternshipSystem.Core.Edition", b =>
                 {
-                    b.HasOne("InternshipSystem.Core.Course", "Course")
+                    b.HasOne("InternshipSystem.Core.Entity.Course", "Course")
                         .WithMany()
                         .HasForeignKey("CourseId")
-                        .HasConstraintName("fk_editions_course_course_id");
+                        .HasConstraintName("fk_editions_courses_course_id");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.Internship", b =>
@@ -566,22 +653,22 @@ namespace InternshipSystem.Repository.Migrations
                     b.HasOne("InternshipSystem.Core.Edition", "Edition")
                         .WithMany("Internships")
                         .HasForeignKey("EditionId")
-                        .HasConstraintName("fk_internship_editions_edition_id");
+                        .HasConstraintName("fk_internships_editions_edition_id");
 
                     b.HasOne("InternshipSystem.Core.Entity.Internship.InternshipRegistration", "InternshipRegistration")
                         .WithMany()
                         .HasForeignKey("InternshipRegistrationId")
-                        .HasConstraintName("fk_internship_internship_registration_internship_registration_");
+                        .HasConstraintName("fk_internships_internship_registration_internship_registration");
 
                     b.HasOne("InternshipSystem.Core.Report", "Report")
                         .WithMany()
                         .HasForeignKey("ReportId")
-                        .HasConstraintName("fk_internship_report_report_id");
+                        .HasConstraintName("fk_internships_report_report_id");
 
                     b.HasOne("InternshipSystem.Core.Student", "Student")
                         .WithMany()
                         .HasForeignKey("StudentId")
-                        .HasConstraintName("fk_internship_students_student_id");
+                        .HasConstraintName("fk_internships_students_student_id");
                 });
 
             modelBuilder.Entity("InternshipSystem.Core.Entity.Internship.InternshipRegistration", b =>
@@ -686,6 +773,23 @@ namespace InternshipSystem.Repository.Migrations
                         .OnDelete(DeleteBehavior.Cascade)
                         .IsRequired();
                 });
+
+            modelBuilder.Entity("InternshipSystem.Core.UglyOrmArtifacts.ReportFieldEdition", b =>
+                {
+                    b.HasOne("InternshipSystem.Core.Edition", "Edition")
+                        .WithMany("ReportSchema")
+                        .HasForeignKey("EditionId")
+                        .HasConstraintName("fk_report_field_edition_editions_edition_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("InternshipSystem.Core.Entity.ReportField", "Field")
+                        .WithMany()
+                        .HasForeignKey("ReportFieldId")
+                        .HasConstraintName("fk_report_field_edition_report_fields_report_field_id")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
 #pragma warning restore 612, 618
         }
     }

test/InternshipSystem.Api.Test/InternshipSystem.cs

@@ -123,7 +123,6 @@ namespace InternshipSystem.Api.Test
                 .Include(i => i.InternshipRegistration)
                     .ThenInclude(c => c.Subjects)
                 .Where(i => i.Student.Id == user.PersonNumber)
-                .Select(i => i.InternshipRegistration)
                 .First();
 
             var useCase = new UpdateInternshipRegistrationUseCase(db, ir, ed, user);
@@ -161,7 +160,6 @@ namespace InternshipSystem.Api.Test
                 .Include(i => i.InternshipRegistration)
                 .ThenInclude(c => c.Subjects)
                 .Where(i => i.Student.Id == user.PersonNumber)
-                .Select(i => i.InternshipRegistration)
                 .First();
         };