diff --git a/Closure_Front_End/package-lock.json b/Closure_Front_End/package-lock.json index f73194de..2e17a225 100644 --- a/Closure_Front_End/package-lock.json +++ b/Closure_Front_End/package-lock.json @@ -13,7 +13,10 @@ "axios": "^0.21.1", "bulma": "^0.9.3", "core-js": "^3.6.5", + "dexie": "^3.0.3", + "swrv": "^1.0.0-beta.8", "vue": "^3.0.0", + "vue-multiselect": "^3.0.0-alpha.2", "vue-router": "^4.0.0-0" }, "devDependencies": { @@ -3785,6 +3788,14 @@ "node": ">=8" } }, + "node_modules/dexie": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/dexie/-/dexie-3.0.3.tgz", + "integrity": "sha512-BSFhGpngnCl1DOr+8YNwBDobRMH0ziJs2vts69VilwetHYOtEDcLqo7d/XiIphM0tJZ2rPPyAGd31lgH2Ln3nw==", + "engines": { + "node": ">=6.0" + } + }, "node_modules/diff-sequences": { "version": "26.6.2", "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-26.6.2.tgz", @@ -9670,6 +9681,14 @@ "node": ">=8" } }, + "node_modules/swrv": { + "version": "1.0.0-beta.8", + "resolved": "https://registry.npmjs.org/swrv/-/swrv-1.0.0-beta.8.tgz", + "integrity": "sha512-MsjaMOvZODfM0cess/HhbSrNbAotYinv4vzipLckKYBo/QmrvjNUPGZSRSqByXy/9AjrMRFWo0YanaVPbqADPQ==", + "peerDependencies": { + "vue": "^3.0.0" + } + }, "node_modules/symbol-tree": { "version": "3.2.4", "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz", @@ -10256,6 +10275,15 @@ "node": ">=0.10.0" } }, + "node_modules/vue-multiselect": { + "version": "3.0.0-alpha.2", + "resolved": "https://registry.npmjs.org/vue-multiselect/-/vue-multiselect-3.0.0-alpha.2.tgz", + "integrity": "sha512-Xp9fGJECns45v+v8jXbCIsAkCybYkEg0lNwr7Z6HDUSMyx2TEIK2giipPE+qXiShEc1Ipn+ZtttH2iq9hwXP4Q==", + "engines": { + "node": ">= 4.0.0", + "npm": ">= 3.0.0" + } + }, "node_modules/vue-router": { "version": "4.0.10", "resolved": "https://registry.npmjs.org/vue-router/-/vue-router-4.0.10.tgz", @@ -13347,6 +13375,11 @@ "integrity": "sha512-TLz+x/vEXm/Y7P7wn1EJFNLxYpUD4TgMosxY6fAVJUnJMbupHBOncxyWUG9OpTaH9EBD7uFI5LfEgmMOc54DsA==", "dev": true }, + "dexie": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/dexie/-/dexie-3.0.3.tgz", + "integrity": "sha512-BSFhGpngnCl1DOr+8YNwBDobRMH0ziJs2vts69VilwetHYOtEDcLqo7d/XiIphM0tJZ2rPPyAGd31lgH2Ln3nw==" + }, "diff-sequences": { "version": "26.6.2", "resolved": "https://registry.npmjs.org/diff-sequences/-/diff-sequences-26.6.2.tgz", @@ -17876,6 +17909,12 @@ } } }, + "swrv": { + "version": "1.0.0-beta.8", + "resolved": "https://registry.npmjs.org/swrv/-/swrv-1.0.0-beta.8.tgz", + "integrity": "sha512-MsjaMOvZODfM0cess/HhbSrNbAotYinv4vzipLckKYBo/QmrvjNUPGZSRSqByXy/9AjrMRFWo0YanaVPbqADPQ==", + "requires": {} + }, "symbol-tree": { "version": "3.2.4", "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz", @@ -18330,6 +18369,11 @@ } } }, + "vue-multiselect": { + "version": "3.0.0-alpha.2", + "resolved": "https://registry.npmjs.org/vue-multiselect/-/vue-multiselect-3.0.0-alpha.2.tgz", + "integrity": "sha512-Xp9fGJECns45v+v8jXbCIsAkCybYkEg0lNwr7Z6HDUSMyx2TEIK2giipPE+qXiShEc1Ipn+ZtttH2iq9hwXP4Q==" + }, "vue-router": { "version": "4.0.10", "resolved": "https://registry.npmjs.org/vue-router/-/vue-router-4.0.10.tgz", diff --git a/Closure_Front_End/package.json b/Closure_Front_End/package.json index b1199a2e..3e201f0f 100644 --- a/Closure_Front_End/package.json +++ b/Closure_Front_End/package.json @@ -18,7 +18,10 @@ "axios": "^0.21.1", "bulma": "^0.9.3", "core-js": "^3.6.5", + "dexie": "^3.0.3", + "swrv": "^1.0.0-beta.8", "vue": "^3.0.0", + "vue-multiselect": "^3.0.0-alpha.2", "vue-router": "^4.0.0-0" }, "devDependencies": { diff --git a/Closure_Front_End/src/App.vue b/Closure_Front_End/src/App.vue index 5328ea9f..0e260617 100644 --- a/Closure_Front_End/src/App.vue +++ b/Closure_Front_End/src/App.vue @@ -6,9 +6,18 @@ Closure()
+ +
+ שם תכנית: + {{ currentCourseplan.name}} + +
+ +
@@ -19,7 +28,7 @@ @@ -27,17 +36,17 @@ -
+
@@ -30,8 +31,27 @@ - \ No newline at end of file diff --git a/Closure_Front_End/src/components/User.vue b/Closure_Front_End/src/components/User.vue index d09407d2..2249bc73 100644 --- a/Closure_Front_End/src/components/User.vue +++ b/Closure_Front_End/src/components/User.vue @@ -1,49 +1,32 @@ diff --git a/Closure_Front_End/src/components/Year.vue b/Closure_Front_End/src/components/Year.vue index fed606eb..aedb38eb 100644 --- a/Closure_Front_End/src/components/Year.vue +++ b/Closure_Front_End/src/components/Year.vue @@ -26,15 +26,15 @@ export default { data() { return { semesters: [ - { id: 1, name: "סמסטר א" }, - { id: 2, name: "סמסטר ב" }, + { id: "FIRST", name: "סמסטר א" }, + { id: "SECOND", name: "סמסטר ב" }, ] }; }, }; - \ No newline at end of file diff --git a/Closure_Front_End/src/save-load/LoadableCoursePlan.vue b/Closure_Front_End/src/save-load/LoadableCoursePlan.vue new file mode 100644 index 00000000..a694f2f9 --- /dev/null +++ b/Closure_Front_End/src/save-load/LoadableCoursePlan.vue @@ -0,0 +1,95 @@ + + + + + \ No newline at end of file diff --git a/Closure_Front_End/src/save-load/SaveAsModal.vue b/Closure_Front_End/src/save-load/SaveAsModal.vue new file mode 100644 index 00000000..0a8f6f87 --- /dev/null +++ b/Closure_Front_End/src/save-load/SaveAsModal.vue @@ -0,0 +1,108 @@ + + + + + \ No newline at end of file diff --git a/Closure_Front_End/src/save-load/SaveMenu.vue b/Closure_Front_End/src/save-load/SaveMenu.vue new file mode 100644 index 00000000..51e44749 --- /dev/null +++ b/Closure_Front_End/src/save-load/SaveMenu.vue @@ -0,0 +1,99 @@ + + + + + \ No newline at end of file diff --git a/Closure_Front_End/src/services/course-service.ts b/Closure_Front_End/src/services/course-service.ts new file mode 100644 index 00000000..a7cbd811 --- /dev/null +++ b/Closure_Front_End/src/services/course-service.ts @@ -0,0 +1,166 @@ +/** + * @file Module responsible for fetching and caching(via IndexedDB) courses from + * the API. + */ + +import Dexie from "dexie"; +import { http } from "@/auth"; +import { djangoPaginatedGet } from './util'; + +// TODO: generate types from backend and centralize them + +type Semester = "FIRST" | "SECOND" | "SUMMER" | "EITHER" | "ANNUAL"; + +type CourseType = + | "MUST" + | "CHOICE" + | "CHOOSE_FROM_LIST" + | "CORNER_STONE" + | "SUPPLEMENTARY"; + +interface CourseModel { + id: number; + course_id: number; + data_year: number; + name: String; + semester: Semester; + is_given_this_year: boolean; + points: number; +} + +interface CourseTypeRecord { + course_pk: number; + track_pk: number; + type: CourseType; +} + +class CourseDB extends Dexie { + courses: Dexie.Table; + types: Dexie.Table; + constructor() { + super("Closure_CourseDB"); + this.version(2024).stores({ + courses: "id, [course_id+db_version], data_year, &[course_id+data_year]", + types: "[course_pk+track_pk]", + }); + this.courses = this.table("courses"); + this.types = this.table("types"); + } +} + +let db = new CourseDB(); +// TODO delete these clears!! + +function compareCourseByYear( + course1: CourseModel, + course2: CourseModel +): number { + if (course1.data_year < course2.data_year) { + return 1; + } + if (course1.data_year > course2.data_year) { + return -1; + } + return 0; +} + +const MAX_POSSIBLE_YEAR = 2022 + +/** Finds all courses with given course ID (with differing years), + * sorted by their years in descending order. + * @param course_id A HUJI course ID + */ +export async function getCoursesForID( + course_id: number +): Promise { + if (!db.isOpen) { + await db.open(); + } + let instances = await db.courses + .where({ + course_id: course_id, + db_version: MAX_POSSIBLE_YEAR, + }) + .toArray(); + if (instances.length === 0) { + [instances] = await djangoPaginatedGet(http, `/courses/`, { + params: { course_id: course_id }, + }); + instances = instances.map(obj => ({...obj, db_version: MAX_POSSIBLE_YEAR})) + await db.courses.bulkPut(instances); + } + instances.sort(compareCourseByYear); + return instances; +} + +/** Caches the given courses in the DB. */ +export async function cacheCourses(courses: CourseModel[]): Promise { + if (!db.isOpen) { + await db.open(); + } + const coursesToCache = courses.map((course) => ({ + ...course, + type: undefined, + })); + await db.courses.bulkPut(coursesToCache); +} + +/** Finds the type of courses(given by their primary keys) within context of a track(given by its primary key) + * @param course_pks The primary keys of the courses whose types we're trying to find. + * @param track_pk The primary key of the track + * @returns A mapping between course PKs to their types. If no type exists(e.g, the coruse doesn't belong to given track), + * null will be given instead. + */ +export async function getCourseTypes( + course_pks: number[], + track_pk: number +): Promise> { + if (!db.isOpen) { + await db.open(); + } + const instances = await db.types + .where(["course_pk", "track_pk"]) + .anyOf(course_pks.map((course_pk) => [course_pk, track_pk])) + .toArray(); + const map = new Map( + instances.map((typeRecord) => [typeRecord.course_pk, typeRecord.type]) + ); + const missing = new Set(course_pks.filter((pk) => !map.has(pk))); + + if (missing.size > 0) { + const [entries] = await djangoPaginatedGet(http, `/tracks/${track_pk}/courses/`, { + params: { + id__in: Array.from(missing).join(","), + limit: missing.size + }, + }); + + await cacheCourses(entries); + await db.types.bulkPut( + entries.map((course) => ({ + course_pk: course.id, + track_pk: track_pk, + type: course.type, + })) + ); + + for (const entry of entries) { + missing.delete(entry.id); + map.set(entry.id, entry.type); + } + } + + for (const stillMissingPk of missing) { + map.set(stillMissingPk, null); + } + await db.types.bulkPut( + [...missing].map((missingCoursePk) => ({ + course_pk: missingCoursePk, + track_pk: track_pk, + type: null, + })) + ); + + console.log("course type map given track ID", track_pk, ":", map); + return map; +} diff --git a/Closure_Front_End/src/services/util.ts b/Closure_Front_End/src/services/util.ts new file mode 100644 index 00000000..bf59dfe8 --- /dev/null +++ b/Closure_Front_End/src/services/util.ts @@ -0,0 +1,26 @@ +import { AxiosInstance, AxiosRequestConfig, AxiosResponse } from "axios"; + + +/** + * Similar to axios 'get', but works with Django's paginated responses, + * yielding all available elements for the query. + * + * @param http Axios HTTP instance + * @param url URL used for initial request + * @param config Axios configuration used for initial request. + * If you want + * @returns Array of payload objects, tupled with an array of response objects. + */ +export async function djangoPaginatedGet(http: AxiosInstance, url: string, config?: AxiosRequestConfig): Promise<[any[], AxiosResponse[]]> +{ + const totalResults = [] + let res = await http.get(url, config) + const totalResponses = [res] + totalResults.push(...res.data.results) + while (res.data.next) { + res = await http.get(res.data.next) + totalResponses.push(res) + totalResults.push(...res.data.results) + } + return [totalResults, totalResponses] +} \ No newline at end of file diff --git a/Closure_Front_End/src/utils.js b/Closure_Front_End/src/utils.js index d7adc8a8..3790cca2 100644 --- a/Closure_Front_End/src/utils.js +++ b/Closure_Front_End/src/utils.js @@ -1,18 +1,3 @@ - -/** A mapping between API "semester" values to the "semester" property used in the front-end, - which indicates their positioning. - */ -export const API_SEMESTER_TO_PROP_INT = new Map(Object.entries({ - FIRST: 1, - SECOND: 2 -})) - -/** A mapping between the "semester" property values used in the front-end, to their corresponding - * values in the backend API - */ -export const PROP_INT_TO_API_SEMESTER = new Map(Array.from(API_SEMESTER_TO_PROP_INT, a => a.reverse())) - - export function isString(x) { return Object.prototype.toString.call(x) === "[object String]" } @@ -24,3 +9,24 @@ export function groupBy(xs, key) { return rv; }, {}); } + +export const MODEL_COURSE_TYPE_TO_STRING = new Map([ + ["MUST", "חובה"], + ["CHOICE", "בחירה"], + ["CHOOSE_FROM_LIST", "חובת בחירה"], + ["CORNER_STONE", "אבן פינה"], + ["SUPPLEMENTARY", "לימודים משלימים"] +]); + +export const MODEL_SEMESTER_TO_STRING = new Map([ + ['FIRST', "סמסטר א'"], + ['SECOND', "סמסטר ב'"], + ['SUMMER', "קורס קיץ"], + ['EITHER', "סמסטר א'/ב'"], + ['ANNUAL', "קורס שנתי"], + // TODO: standardize model types in the code to avoid this + // duplictation + [1, "סמסטר א'"], + [2, "סמסטר ב'"] +]); + diff --git a/Closure_Front_End/src/views/CourseImport.vue b/Closure_Front_End/src/views/CourseImport.vue index d91273ba..70d5a380 100644 --- a/Closure_Front_End/src/views/CourseImport.vue +++ b/Closure_Front_End/src/views/CourseImport.vue @@ -51,7 +51,6 @@ import Instructions from "@/huji-import/Instructions.vue"; import { default as INITIAL_COURSES } from "@/huji-import/example-parsed-courses.js"; import { TRY_HOOK_MESSAGE_TYPE, HOOKED_MESSAGE_TYPE, STARTED_MESSAGE_TYPE, GOT_COURSE_MESSAGE_TYPE, FINISHED_PARSING_MESSAGE_TYPE } from '@/huji-import/course-scrape-communication.js' import ParsedCoursesTables from "@/huji-import/ParsedCoursesTables.vue"; -import { API_SEMESTER_TO_PROP_INT } from "@/utils.js"; const HUJI_ORIGIN = "https://www.huji.ac.il"; @@ -119,12 +118,15 @@ export default { this.courses.push({ ...course, key: this.courses.length }); }, onImportCourses({ courses, importMode }) { - const firstYear = Math.min(...courses.map(course => course.year)); + console.log('onImportCourses', courses) + const firstYear = Math.min(...courses.map(course => course.take.year)); const coursesForDisplay = courses.map(course => { return { ...course, - year: course.year - firstYear + 1, - semester: API_SEMESTER_TO_PROP_INT.get(course.semester) + take: { + year: course.take.year - firstYear + 1, + semester: course.take.semester + } }; }); addCourses(coursesForDisplay, importMode === 'overwrite'); diff --git a/Closure_Front_End/src/views/CoursePlan.vue b/Closure_Front_End/src/views/CoursePlan.vue new file mode 100644 index 00000000..0afac166 --- /dev/null +++ b/Closure_Front_End/src/views/CoursePlan.vue @@ -0,0 +1,159 @@ + + + + + \ No newline at end of file diff --git a/Closure_Front_End/src/views/Home.vue b/Closure_Front_End/src/views/Home.vue index 40d6fc51..286f2e69 100644 --- a/Closure_Front_End/src/views/Home.vue +++ b/Closure_Front_End/src/views/Home.vue @@ -1,13 +1,24 @@ diff --git a/Closure_Front_End/src/views/Settings.vue b/Closure_Front_End/src/views/Settings.vue index 2321c8e6..55ad3d82 100644 --- a/Closure_Front_End/src/views/Settings.vue +++ b/Closure_Front_End/src/views/Settings.vue @@ -1,45 +1,43 @@ diff --git a/Closure_Front_End/tests/unit/App.spec.js b/Closure_Front_End/tests/unit/App.spec.js index 23627622..d382c7a3 100644 --- a/Closure_Front_End/tests/unit/App.spec.js +++ b/Closure_Front_End/tests/unit/App.spec.js @@ -13,8 +13,8 @@ describe('App.vue', () => { const mountOptions = { global: { - mocks: { - $auth: authMock + provide: { + auth: authMock } } } diff --git a/Closure_Project/project_settings/settings.py b/Closure_Project/project_settings/settings.py index f08fdf24..bbf4bbc2 100644 --- a/Closure_Project/project_settings/settings.py +++ b/Closure_Project/project_settings/settings.py @@ -91,8 +91,8 @@ } AUTHENTICATION_BACKENDS = [ + 'django.contrib.auth.backends.ModelBackend', 'django.contrib.auth.backends.RemoteUserBackend', - 'django.contrib.auth.backends.ModelBackend' ] # Application definition diff --git a/Closure_Project/requirements.txt b/Closure_Project/requirements.txt index 17c9cbc9..acf61c83 100644 --- a/Closure_Project/requirements.txt +++ b/Closure_Project/requirements.txt @@ -17,6 +17,7 @@ djangorestframework-jwt==1.11.0 tqdm>=4.61.2 django-cors-headers==3.6.0 drf_yasg==1.20.0 +drf-nested-routers~=0.93.3 django-filter~=2.4.0 PyJWT[crypto]~=1.7.1 gunicorn==20.1.0 diff --git a/Closure_Project/rest_api/admin.py b/Closure_Project/rest_api/admin.py index b15bc690..4e9087d6 100644 --- a/Closure_Project/rest_api/admin.py +++ b/Closure_Project/rest_api/admin.py @@ -1,12 +1,10 @@ from django.contrib import admin # Register your models here. -from django.contrib import admin -from .models import Course, Student, CourseGroup, Track, Take +from .models import Course, Student, CourseGroup, Track, Take, CoursePlan admin.site.register(Course) admin.site.register(Student) admin.site.register(CourseGroup) admin.site.register(Track) admin.site.register(Take) - - +admin.site.register(CoursePlan) \ No newline at end of file diff --git a/Closure_Project/rest_api/migrations/0005_auto_20210828_2323.py b/Closure_Project/rest_api/migrations/0005_auto_20210828_2323.py new file mode 100644 index 00000000..3a638d06 --- /dev/null +++ b/Closure_Project/rest_api/migrations/0005_auto_20210828_2323.py @@ -0,0 +1,49 @@ +# Generated by Django 3.2.4 on 2021-08-28 20:23 + +from django.db import migrations, models +import django.db.models.deletion + + +class Migration(migrations.Migration): + + dependencies = [ + ('rest_api', '0004_auto_20210629_0256'), + ] + + operations = [ + migrations.RemoveField( + model_name='student', + name='courses', + ), + migrations.RemoveField( + model_name='student', + name='track', + ), + migrations.RemoveField( + model_name='student', + name='year_in_studies', + ), + migrations.RemoveField( + model_name='take', + name='student', + ), + migrations.CreateModel( + name='CoursePlan', + fields=[ + ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), + ('name', models.TextField(max_length=50, null=True)), + ('public', models.BooleanField(default=False)), + ('created_at', models.DateTimeField(auto_now_add=True)), + ('modified_at', models.DateTimeField(auto_now=True)), + ('courses', models.ManyToManyField(blank=True, through='rest_api.Take', to='rest_api.Course')), + ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='rest_api.student')), + ('track', models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, to='rest_api.track')), + ], + ), + migrations.AddField( + model_name='take', + name='course_plan', + field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='rest_api.courseplan'), + preserve_default=False, + ), + ] diff --git a/Closure_Project/rest_api/models.py b/Closure_Project/rest_api/models.py index bb984350..e5f49aa0 100644 --- a/Closure_Project/rest_api/models.py +++ b/Closure_Project/rest_api/models.py @@ -1,7 +1,6 @@ # Create your models here. -import uuid from enum import Enum -from typing import List +from typing import Any, List, Dict, Optional from django.core.exceptions import ValidationError @@ -204,20 +203,30 @@ def __str__(self): class Student(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE) - track = models.ForeignKey(Track, on_delete=models.CASCADE, null=True) - year_in_studies = models.IntegerField(choices=Year.choices, null=True) - courses = models.ManyToManyField(Course, through='Take', blank=True) def __str__(self): return ', '.join((self.user.username, self.user.get_full_name(), - f'year={self.year_in_studies}', - f'track={self.track.track_number}' if self.track else 'לא הוגדר מסלול', - f'took {len(self.courses.all())} courses')) + f'has {len(self.courseplan_set.all())} course plans')) + +class CoursePlan(models.Model): + owner = models.ForeignKey(Student, on_delete=models.CASCADE) + name = models.TextField(null=True, max_length=50) + public = models.BooleanField(default=False) + created_at = models.DateTimeField(auto_now_add=True) + modified_at = models.DateTimeField(auto_now=True) + track = models.ForeignKey(Track, on_delete=models.CASCADE, null=True) + courses = models.ManyToManyField(Course, through='Take', blank=True) + + @property + def year_in_studies(self) -> Optional[int]: + return self.track.data_year if self.track else None @property - def remaining(self): + def remaining(self) -> Optional[Dict[str, Any]]: track = self.track + if not track: + return None groups = track.coursegroup_set.all() required_by_type = {k: set() for k in REQUIRED_COURSE_TYPES} required_courses = set() @@ -272,10 +281,10 @@ def trickle_down(trickle_from: CourseType, trickle_to: CourseType) -> None: trickle_down(CourseType.CORNER_STONE, CourseType.SUPPLEMENTARY) return result - + class Take(models.Model): - student = models.ForeignKey(Student, on_delete=models.CASCADE) + course_plan = models.ForeignKey(CoursePlan, on_delete=models.CASCADE) course = models.ForeignKey(Course, on_delete=models.CASCADE) year_in_studies = models.IntegerField(choices=Year.choices) semester = models.TextField(choices=Semester.choices) @@ -286,6 +295,8 @@ def __str__(self): f'semester={self.semester.lower()}')) @property - def type(self) -> CourseType: + def type(self) -> Optional[CourseType]: from rest_api.rest_utils import get_course_type - return get_course_type(self.student.track, self.course) + if self.course_plan.track: + return get_course_type(self.course_plan.track, self.course) + return None diff --git a/Closure_Project/rest_api/pagination.py b/Closure_Project/rest_api/pagination.py index a154675a..12f44c1d 100644 --- a/Closure_Project/rest_api/pagination.py +++ b/Closure_Project/rest_api/pagination.py @@ -1,26 +1,6 @@ -from django.core.exceptions import BadRequest from rest_framework.pagination import LimitOffsetPagination -def _validate_limit(integer_string: str, max_value: int): - """ ensures the requested number of results doesn't exceed the maximal number allowed """ - num = int(integer_string) - if num <= 0 or num > max_value: - raise BadRequest(f'limit must be between 1 and {max_value}') - return num - - class ResultSetPagination(LimitOffsetPagination): default_limit = 10 max_limit = 100 - - def get_limit(self, request): - if self.limit_query_param: - try: - return _validate_limit( - request.query_params[self.limit_query_param], - self.max_limit - ) - except KeyError: - pass - return self.default_limit diff --git a/Closure_Project/rest_api/permissions.py b/Closure_Project/rest_api/permissions.py new file mode 100644 index 00000000..45742a56 --- /dev/null +++ b/Closure_Project/rest_api/permissions.py @@ -0,0 +1,34 @@ +from rest_framework import permissions + +from rest_api.models import CoursePlan +from rest_framework.request import HttpRequest + + +def request_is_authenticated(request: HttpRequest) -> bool: + return bool(request.user and request.user.is_authenticated) + +class CoursePlanPermission(permissions.BasePermission): + """ Allows anyone to read the course plan if it is public. + The owner of the course plan can do anything with it. """ + + def has_permission(self, request, view): + if request.method in permissions.SAFE_METHODS: + return True + return request_is_authenticated(request) + + def has_object_permission(self, request: HttpRequest, view, obj: CoursePlan): + is_authenticated = request_is_authenticated(request) + belongs_to_requester = is_authenticated and obj.owner.user == request.user + if request.method in permissions.SAFE_METHODS: + return belongs_to_requester or obj.public + + return belongs_to_requester + +class IsAdminOrAuthenticatedReadOnly(permissions.IsAdminUser): + """ Allows read-only access to authenticated users, and update access + to admins only. """ + def has_permission(self, request, view): + if request.method in permissions.SAFE_METHODS: + return request_is_authenticated(request) + + return super().has_permission(request, view) \ No newline at end of file diff --git a/Closure_Project/rest_api/rest_utils.py b/Closure_Project/rest_api/rest_utils.py index 4037cc2b..8aff27c0 100644 --- a/Closure_Project/rest_api/rest_utils.py +++ b/Closure_Project/rest_api/rest_utils.py @@ -35,7 +35,7 @@ def get_course_type(track: Track, course: Course) -> Optional[CourseType]: def jwt_get_username_from_payload_handler(payload): - username = payload.get('nickname') + username = payload.get('sub').replace('|', '.') authenticate(remote_user=username) return username diff --git a/Closure_Project/rest_api/serializers/CourseGroupSerializer.py b/Closure_Project/rest_api/serializers/CourseGroupSerializer.py index 8c8393e2..352c571a 100644 --- a/Closure_Project/rest_api/serializers/CourseGroupSerializer.py +++ b/Closure_Project/rest_api/serializers/CourseGroupSerializer.py @@ -4,7 +4,7 @@ class CourseGroupSerializer(DynamicFieldsModelSerializer): - courses = CourseSerializer(fields=('pk', 'course_id', 'name', 'semester', 'points'), many=True, read_only=True) + courses = CourseSerializer(fields=('id', 'course_id', 'name', 'semester', 'points'), many=True, read_only=True) class Meta: model = CourseGroup diff --git a/Closure_Project/rest_api/serializers/CoursePlanSerializer.py b/Closure_Project/rest_api/serializers/CoursePlanSerializer.py new file mode 100644 index 00000000..acaad9ae --- /dev/null +++ b/Closure_Project/rest_api/serializers/CoursePlanSerializer.py @@ -0,0 +1,66 @@ +from rest_api.serializers.DynamicSerializer import DynamicFieldsModelSerializer, serializers +from rest_api.models import Take, CoursePlan +from rest_api.serializers.CourseSerializer import CourseOfTrackSerializer +from rest_api.serializers.TrackSerializer import TrackSerializer + +class TakeSerializer(DynamicFieldsModelSerializer): + type = serializers.StringRelatedField(read_only=True) + + class Meta: + model = Take + fields = ('course', 'course_plan_id', 'year_in_studies', 'semester', 'type') + +class DetailTakeSerializer(TakeSerializer): + course = CourseOfTrackSerializer(read_only=True) + + class Meta: + model = Take + fields = TakeSerializer.Meta.fields + + +class CoursePlanSerializer(DynamicFieldsModelSerializer): + takes = TakeSerializer(many=True, source="take_set", partial=True) + owner = serializers.ReadOnlyField(source="owner.id") + track_name = serializers.ReadOnlyField(source="track.name") + + remaining = serializers.JSONField(read_only=True) + + class Meta: + model = CoursePlan + fields = ('id', 'owner', 'name', 'track', 'track_name', 'public', 'remaining', 'created_at', 'modified_at', 'takes') + read_only_fields = ('id', 'created_at', 'modified_at') + + + def create(self, validated_data): + takes = validated_data.pop("take_set") + + plan = CoursePlan.objects.create(**validated_data) + if takes: + for take in takes: + Take.objects.create(course_plan=plan, **take) + return plan + + def update(self, instance, validated_data): + takes = validated_data.pop("take_set", None) + + CoursePlan.objects.filter(id=instance.id).update(**validated_data) + if takes: + Take.objects.filter(course_plan=instance).delete() + for take in takes: + Take.objects.create(course_plan=instance, **take) + return CoursePlan.objects.get(id=instance.id) + +class DetailCoursePlanSerializer(CoursePlanSerializer): + takes = DetailTakeSerializer(many=True, source="take_set") + track = TrackSerializer() + + + def to_representation(self, instance): + track = self.fields["track"].get_attribute(instance) + self.context["track_pk"] = track.id if track else None + return super().to_representation(instance) + + class Meta: + model = CoursePlan + fields = CoursePlanSerializer.Meta.fields + read_only_fields = CoursePlanSerializer.Meta.read_only_fields \ No newline at end of file diff --git a/Closure_Project/rest_api/serializers/CourseSerializer.py b/Closure_Project/rest_api/serializers/CourseSerializer.py index c9dc2db5..7982038f 100644 --- a/Closure_Project/rest_api/serializers/CourseSerializer.py +++ b/Closure_Project/rest_api/serializers/CourseSerializer.py @@ -1,22 +1,37 @@ +from typing import Optional from rest_api.serializers.DynamicSerializer import DynamicFieldsModelSerializer from rest_framework import serializers -from rest_api.models import Course, Student +from rest_api.models import Course, CourseType, Track from rest_api.rest_utils import get_course_type - class CourseSerializer(DynamicFieldsModelSerializer): - pk = serializers.PrimaryKeyRelatedField(source='id', read_only=True) + class Meta: + model = Course + fields = ('id', 'course_id', 'data_year', 'name', 'semester', 'points', 'is_given_this_year', + 'is_corner_stone', 'comment') + read_only_fields = ('id',) + +class CourseOfTrackSerializer(CourseSerializer): type = serializers.SerializerMethodField(method_name='get_type') - def get_type(self, obj): - user = self.context.get('request').user - try: - student = Student.objects.get(user=user) - except Student.DoesNotExist: - return None - return get_course_type(student.track, obj) + def get_type(self, obj) -> Optional[CourseType]: + + # try obtaining track ID set by a parent serializer (e.g, + # DetailCoursePlanSerializer) + track_id = self.context.get("track_pk", None) + + if not track_id: + # otherwise, try obtaining it from the HTTP request, + # if its of the form /tracks/:track_pk/... + request = self.context['request'] + track_id = request.parser_context["kwargs"].get("track_pk", None) + + if track_id: + track = Track.objects.get(id=track_id) + return get_course_type(track, obj) + + return None class Meta: model = Course - fields = ('pk', 'course_id', 'data_year', 'name', 'semester', 'points', 'type', 'is_given_this_year', - 'is_corner_stone', 'comment') + fields = CourseSerializer.Meta.fields + ('type', ) \ No newline at end of file diff --git a/Closure_Project/rest_api/serializers/StudentSerializer.py b/Closure_Project/rest_api/serializers/StudentSerializer.py index e86dedda..ca37f102 100644 --- a/Closure_Project/rest_api/serializers/StudentSerializer.py +++ b/Closure_Project/rest_api/serializers/StudentSerializer.py @@ -1,37 +1,17 @@ from django.contrib.auth.models import User -from rest_api.serializers.DynamicSerializer import * +from rest_api.serializers.DynamicSerializer import serializers, DynamicFieldsModelSerializer from rest_api.models import Student, Take, Track -from .TakeSerializer import TakeSerializer +from .CoursePlanSerializer import CoursePlanSerializer from .TrackSerializer import TrackSerializer from django.shortcuts import get_object_or_404 class StudentSerializer(DynamicFieldsModelSerializer): - courses = TakeSerializer(source='take_set', many=True) - pk = serializers.PrimaryKeyRelatedField(source='id', - read_only=True) username = serializers.CharField(source='user.username', read_only=True) - track_pk = serializers.PrimaryKeyRelatedField(source='track', - queryset=Track.objects.all()) - track = TrackSerializer(fields=('track_number', 'name'), read_only=True) - remaining = serializers.JSONField(read_only=True) + course_plans = CoursePlanSerializer(source='courseplan_set', many=True, read_only=True) class Meta: model = Student - fields = ('pk', 'username', 'track_pk', 'track', 'year_in_studies', 'remaining', 'courses') - - def update(self, student: Student, validated_data): - take_set = validated_data.pop('take_set') - student.track = validated_data.get('track', student.track) - student.year_in_studies = validated_data.get('year_in_studies', student.year_in_studies) - student.courses.clear() - for take in take_set: - Take.objects.create(student=student, - course=take['course'], - year_in_studies=take['year_in_studies'], - semester=take['semester']) - - student.save() - return student + fields = ('id', 'username', 'course_plans') diff --git a/Closure_Project/rest_api/serializers/TakeSerializer.py b/Closure_Project/rest_api/serializers/TakeSerializer.py deleted file mode 100644 index 7bfe58cc..00000000 --- a/Closure_Project/rest_api/serializers/TakeSerializer.py +++ /dev/null @@ -1,13 +0,0 @@ -from rest_api.serializers.DynamicSerializer import * -from rest_api.models import Course, Take -from .CourseSerializer import CourseSerializer - - -class TakeSerializer(DynamicFieldsModelSerializer): - course = CourseSerializer(fields=('id', 'course_id', 'name', 'semester', 'points'), read_only=True) - pk = serializers.PrimaryKeyRelatedField(source='course', queryset=Course.objects.all()) - type = serializers.StringRelatedField(read_only=True) - - class Meta: - model = Take - fields = ('pk', 'course', 'year_in_studies', 'semester', 'type') diff --git a/Closure_Project/rest_api/serializers/TrackSerializer.py b/Closure_Project/rest_api/serializers/TrackSerializer.py index 58e65978..c0312d60 100644 --- a/Closure_Project/rest_api/serializers/TrackSerializer.py +++ b/Closure_Project/rest_api/serializers/TrackSerializer.py @@ -1,15 +1,21 @@ -from rest_api.serializers.DynamicSerializer import * +from rest_api.serializers.DynamicSerializer import DynamicFieldsModelSerializer, serializers from rest_api.models import Track from .CourseGroupSerializer import CourseGroupSerializer class TrackSerializer(DynamicFieldsModelSerializer): - pk = serializers.PrimaryKeyRelatedField(source='id', read_only=True) - course_groups = CourseGroupSerializer(source='coursegroup_set', many=True, read_only=True) total_points = serializers.IntegerField(read_only=True) class Meta: model = Track - fields = ('pk', 'track_number', 'name', 'data_year', 'total_points', 'points_must', 'points_from_list', + fields = ('id', 'track_number', 'name', 'data_year', 'total_points', 'points_must', 'points_from_list', 'points_choice', 'points_complementary', 'points_corner_stones', - 'points_minor', 'points_additional_hug', 'comment', 'course_groups') + 'points_minor', 'points_additional_hug', 'comment') + read_only_fields = ('id',) + +class TrackSerializerWithCourseGroups(TrackSerializer): + course_groups = CourseGroupSerializer(source='coursegroup_set', many=True, read_only=True) + + class Meta: + model = Track + fields = TrackSerializer.Meta.fields + ('course_groups', ) diff --git a/Closure_Project/rest_api/signals.py b/Closure_Project/rest_api/signals.py index b91efa69..9ca3bdc2 100644 --- a/Closure_Project/rest_api/signals.py +++ b/Closure_Project/rest_api/signals.py @@ -10,4 +10,5 @@ @receiver(post_save, sender=User) def create_student(sender, instance: User, created, **kwargs): if created: - Student.objects.create(user=instance) + student = Student.objects.create(user=instance) + student.save() \ No newline at end of file diff --git a/Closure_Project/rest_api/urls.py b/Closure_Project/rest_api/urls.py index 220fe113..e92874f7 100644 --- a/Closure_Project/rest_api/urls.py +++ b/Closure_Project/rest_api/urls.py @@ -1,6 +1,7 @@ from django.urls import include, path from drf_yasg.views import get_schema_view -from rest_framework import routers, permissions +from rest_framework import permissions +from rest_framework_nested import routers from drf_yasg import openapi from django.conf.urls import url from . import views @@ -10,8 +11,13 @@ router.register(r'course_groups', views.CourseGroupViewSet) router.register(r'students', views.StudentGroupViewSet) router.register(r'tracks', views.TrackViewSet) + +course_tracks_router = routers.NestedSimpleRouter(router, r'tracks', lookup='track') +course_tracks_router.register(r'courses', views.TrackCoursesViewSet) + router.register(r'student/me', views.StudentMeViewSet, basename='Student') router.register(r'track_courses', views.MyTrackCourses, basename='Course') +router.register(r'course_plans', views.CoursePlanViewSet, basename='CoursePlans') schema_view = get_schema_view( openapi.Info( @@ -30,6 +36,7 @@ # Additionally, we include login URLs for the browsable API. urlpatterns = [ path('api/v1/', include(router.urls)), + path('api/v1/', include(course_tracks_router.urls)), url(r'^swagger(?P\.json|\.yaml)$', schema_view.without_ui(cache_timeout=0), name='schema-json'), url(r'^swagger/$', schema_view.with_ui('swagger', cache_timeout=0), name='schema-swagger-ui'), url(r'^redoc/$', schema_view.with_ui('redoc', cache_timeout=0), name='schema-redoc'), diff --git a/Closure_Project/rest_api/views.py b/Closure_Project/rest_api/views.py index 5a8f0abe..72252ca6 100644 --- a/Closure_Project/rest_api/views.py +++ b/Closure_Project/rest_api/views.py @@ -1,31 +1,54 @@ # Create your views here -from django.db.models import Case, When +from django.db.models import Case, When, Q +from django.utils.timezone import make_aware from rest_framework import filters from rest_framework import viewsets from rest_framework.decorators import action from rest_framework.permissions import IsAuthenticated, IsAdminUser from django_filters.rest_framework import DjangoFilterBackend +from rest_framework.request import HttpRequest from rest_framework.response import Response +from datetime import datetime -from .models import Course, Student, CourseGroup, Track, Take +from rest_framework_nested.viewsets import NestedViewSetMixin +from .permissions import CoursePlanPermission, IsAdminOrAuthenticatedReadOnly +from .models import Course, CourseType, Student, CourseGroup, Track, Take, CoursePlan from .pagination import ResultSetPagination -from .serializers.CourseSerializer import CourseSerializer +from .serializers.CourseSerializer import CourseSerializer, CourseOfTrackSerializer from .serializers.CourseGroupSerializer import CourseGroupSerializer from .serializers.StudentSerializer import StudentSerializer -from .serializers.TrackSerializer import TrackSerializer -from .serializers.TakeSerializer import TakeSerializer +from .serializers.TrackSerializer import TrackSerializer, TrackSerializerWithCourseGroups +from .serializers.CoursePlanSerializer import TakeSerializer, DetailTakeSerializer, CoursePlanSerializer, DetailCoursePlanSerializer class CourseViewSet(viewsets.ModelViewSet): - permission_classes = (IsAuthenticated,) - queryset = Course.objects.all().order_by('course_id') + permission_classes = (IsAdminOrAuthenticatedReadOnly,) + queryset = Course.objects.all().order_by('course_id').distinct() serializer_class = CourseSerializer filter_backends = (DjangoFilterBackend, filters.SearchFilter) - filter_fields = ('course_id', 'data_year', 'points') + filter_fields = { + 'id': ['exact', 'in'], + 'course_id': ['exact', 'in'], + 'data_year': ['exact', 'in'], + 'points': ['exact', 'in'] + } pagination_class = ResultSetPagination search_fields = ('name', '^course_id') +class TrackCoursesViewSet(CourseViewSet, NestedViewSetMixin): + filter_backends = (DjangoFilterBackend, ) + filter_fields = {**CourseViewSet.filter_fields, 'coursegroup__course_type': ['exact', 'in']} + pagination_class = ResultSetPagination + + serializer_class = CourseOfTrackSerializer + def get_queryset(self): + if getattr(self, 'swagger_fake_view', False): + relevant_cgs = CourseGroup.objects.all() + else: + relevant_cgs = CourseGroup.objects.filter(track=self.kwargs['track_pk']) + courses = Course.objects.filter(coursegroup__in=relevant_cgs).distinct() + return courses class MyTrackCourses(viewsets.ModelViewSet): def _get_queryset(self, only_must: bool): @@ -96,15 +119,13 @@ class StudentGroupViewSet(viewsets.ModelViewSet): queryset = Student.objects.all().order_by('user__username') serializer_class = StudentSerializer filter_backends = (filters.SearchFilter, DjangoFilterBackend) - filter_fields = ('user__username', 'year_in_studies', 'track__track_number', - 'courses__course_id') + filter_fields = ('user__username',) pagination_class = ResultSetPagination - search_fields = ('user__username', 'year_in_studies', '^track__track_number', - '^courses__course_id') + search_fields = ('user__username',) class TrackViewSet(viewsets.ModelViewSet): - permission_classes = (IsAuthenticated,) + permission_classes = (IsAdminOrAuthenticatedReadOnly,) queryset = Track.objects.all().order_by('track_number') serializer_class = TrackSerializer filter_backends = (DjangoFilterBackend, filters.SearchFilter) @@ -112,8 +133,44 @@ class TrackViewSet(viewsets.ModelViewSet): pagination_class = ResultSetPagination search_fields = ('name', '^track_number') + def get_serializer_class(self): + if self.action == 'list': + return TrackSerializer + return TrackSerializerWithCourseGroups class TakeGroupViewSet(viewsets.ModelViewSet): - permission_classes = (IsAuthenticated,) + permission_classes = (IsAdminUser,) queryset = Take.objects.all().order_by('course') - serializer_class = TakeSerializer + + def get_serializer_class(self): + if self.action == 'retrieve': + return DetailTakeSerializer + return TakeSerializer + +class CoursePlanViewSet(viewsets.ModelViewSet): + permission_classes = (CoursePlanPermission,) + + def get_serializer_class(self): + if self.action == 'retrieve': + return DetailCoursePlanSerializer + return CoursePlanSerializer + + def get_queryset(self): + + public_plans = Q(public=True) + + if not self.request.user or not self.request.user.is_authenticated: + return CoursePlan.objects.filter(public_plans) + student = get_request_student(self.request) + return CoursePlan.objects.filter(Q(owner=student) | public_plans) + + def perform_create(self, serializer): + student = get_request_student(self.request) + serializer.save(owner=student) + + def perform_update(self, serializer): + serializer.save(modified_at=make_aware(datetime.now())) + + +def get_request_student(req: HttpRequest) -> Student: + return Student.objects.get(user=req.user.id) \ No newline at end of file diff --git a/Closure_Project/tests/test_courseplan.py b/Closure_Project/tests/test_courseplan.py new file mode 100644 index 00000000..87bbaf2f --- /dev/null +++ b/Closure_Project/tests/test_courseplan.py @@ -0,0 +1,229 @@ +from typing import Any, Dict +import pytest +import json +import io +from rest_framework.test import APIRequestFactory, force_authenticate +from rest_framework import status + +from rest_api import models +from rest_api.views import CoursePlanViewSet +from rest_api.serializers.CoursePlanSerializer import CoursePlanSerializer + +def create_dummy_student(username: str) -> models.Student: + user = models.User(username=username) + user.save() + owner = models.Student.objects.get(user=user) + return owner + +@pytest.fixture +def courses(): + courses = [ + models.Course(course_id=1330, data_year=2015, name="Course A", semester=models.Semester.A, is_given_this_year=True, points=4), + models.Course(course_id=1331, data_year=2015, name="Course B", semester=models.Semester.B, is_given_this_year=True, points=4), + models.Course(course_id=1332, data_year=2015, name="Course C", semester=models.Semester.A, is_given_this_year=True, points=4), + models.Course(course_id=1333, data_year=2015, name="Course D", semester=models.Semester.EITHER, is_given_this_year=True, points=4), + ] + models.Course.objects.bulk_create(courses) + return models.Course.objects.all() + + + +@pytest.mark.django_db +def test_courseplan_serializer(courses): + owner = create_dummy_student("Stu A") + # print("courses", courses) + # print("courseplan serializer", repr(CoursePlanSerializer())) + + # deserialization + course_plan = { + "public": False, + "takes": [ + { "course": courses[0].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.FIRST.value }, + { "course": courses[1].id, "semester": models.Semester.B.value, "year_in_studies": models.Year.FIRST.value }, + { "course": courses[3].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.SECOND.value } + ] + } + + deserializer = CoursePlanSerializer(data=course_plan) + assert deserializer.is_valid(), f"Gotten errors: {deserializer.errors}" + # print("deserializer validated_data", deserializer.validated_data) + model_course_plan = deserializer.save(owner=owner) + model_takes = model_course_plan.take_set.all() + + assert len(model_takes) == len(course_plan["takes"]), "The deserialized model object should match the data object" + assert all(take.course_plan_id == model_course_plan.id + for take in model_takes), "The deserialized model object should match the data object" + + assert model_course_plan.id is not None, "Deserialized model object should have an ID" + assert model_course_plan.owner.id == owner.id + + # print("model_takes", model_takes) + + # very simple testing of serialization + serializer = CoursePlanSerializer(model_course_plan) + serialization_result = serializer.data + + assert len(serialization_result["takes"]) == len(course_plan["takes"]) + + # now, updating the previous instance, adding a title and changing the takes + course_plan_2 = { + "id": model_course_plan.id, + "name": "now i have a name", + "public": False, + "takes": [ + { "course": courses[0].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.FIRST.value }, + { "course": courses[2].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.SECOND.value }, + ] + } + + + deserializer_2 = CoursePlanSerializer(model_course_plan, data=course_plan_2) + assert deserializer_2.is_valid() + model_course_plan_2 = deserializer_2.save() + + assert models.CoursePlan.objects.count() == 1 + assert models.Take.objects.count() == 2, "Old takes should have been deleted" + assert model_course_plan_2.name == course_plan_2["name"], "should have a name now" + + +@pytest.fixture +def view(): + return CoursePlanViewSet.as_view(actions={'post': 'create', 'put': 'update', 'get': 'retrieve', 'patch': 'partial_update'}) + +@pytest.fixture +def stud1(): + return create_dummy_student("alice") + +@pytest.fixture +def stud2(): + return create_dummy_student("bob") + +@pytest.fixture +def stud1_plan(courses): + return { + "name": "a private plan", + "public": False, + "takes": [ + { "course": courses[0].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.FIRST.value }, + { "course": courses[1].id, "semester": models.Semester.B.value, "year_in_studies": models.Year.FIRST.value }, + { "course": courses[3].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.SECOND.value } + ] + } + +@pytest.fixture +def stud2_plan(courses): + return { + "name": "a public plan", + "public": True, + "takes": [ + { "course": courses[0].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.FIRST.value }, + { "course": courses[2].id, "semester": models.Semester.A.value, "year_in_studies": models.Year.SECOND.value }, + ] + } + +@pytest.fixture +def factory(): + return APIRequestFactory() + + +@pytest.fixture +def post_plan(factory, view): + def _fun(plan, student: models.Student) -> Dict[Any, Any]: + req = factory.post('/course_plans/', plan, format='json') + force_authenticate(req, student.user) + res = view(req) + assert res.status_code == status.HTTP_201_CREATED, "Creating a course plan should succeed" + + res.render() + post_result = json.load(io.BytesIO(res.content)) + assert post_result["owner"] == student.id, "The owner field should be automatically populated" + assert post_result["owner"] == student.id, "The owner field should be automatically populated" + return post_result + + return _fun + +@pytest.mark.django_db +def test_courseplan_post(post_plan, stud1, stud1_plan): + post_plan(stud1_plan, stud1) + +@pytest.mark.django_db +def test_courseplan_partial_update(view, stud1, stud1_plan, post_plan): + factory = APIRequestFactory() + + # post + post_result = post_plan(stud1_plan, stud1) + + # partial update + stud1_req2 = factory.patch('/course_plans/', { "name": "cool name"}, format='json') + force_authenticate(stud1_req2, stud1.user) + res2 = view(stud1_req2, pk = post_result["id"]) + + assert res2.status_code == status.HTTP_200_OK, "Patching a course plan should succeed" + res2.render() + patch_result = json.load(io.BytesIO(res2.content)) + + print("patch_result", patch_result) + assert patch_result["name"] == "cool name", "patched name was changed" + assert patch_result["modified_at"] > patch_result["created_at"] + assert len(patch_result["takes"]) == len(stud1_plan["takes"]), "a patch that doesn't include takes, does not change them" + + + + + + +@pytest.mark.django_db +def test_courseplan_viewset_permissions(courses, view, stud1, stud2, stud1_plan, stud2_plan, post_plan): + factory = APIRequestFactory() + + # setup, create a plan for each student + plan1_res = post_plan(stud1_plan, stud1) + plan2_res = post_plan(stud2_plan, stud2) + print("res1", plan1_res) + print("res2", plan2_res) + + # stud1 can access his own plan + stud1_req2 = factory.get('/course_plans/') + force_authenticate(stud1_req2, stud1.user) + res3 = view(stud1_req2, pk=plan1_res["id"]) + assert res3.status_code == status.HTTP_200_OK + + res3.render() + plan1_res2 = json.load(io.BytesIO(res3.content)) + assert plan1_res2 == plan1_res, "The retrieved plan is identical to the one created" + + # and also access stud2's plan, which is public + stud1_req3 = factory.get('/course_plans/') + force_authenticate(stud1_req3, stud1.user) + res4 = view(stud1_req3, pk=plan2_res["id"]) + assert res4.status_code == status.HTTP_200_OK, "Student 1 can access a public plan" + res4.render() + res4_data = json.load(io.BytesIO(res4.content)) + assert res4_data == plan2_res, "The retrieved plan is identical to the one created" + + # which can also be accessed without being authenticated at all + unauth_req = factory.get('/course_plans/') + res5 = view(unauth_req, pk=plan2_res["id"]) + assert res5.status_code == status.HTTP_200_OK, "An unauthenticated user can access a public plan" + res5.render() + res5_data = json.load(io.BytesIO(res5.content)) + assert res5_data == plan2_res, "The retrieved plan is identical to the one created" + + # however, stud1 cannot modify stud2's plan + stud1_modify_req = factory.patch("/course_plans/") + force_authenticate(stud1_modify_req, stud1.user) + modify_res = view(stud1_modify_req, pk=plan2_res["id"]) + assert modify_res.status_code == status.HTTP_403_FORBIDDEN, "A plan can only be modified by its user" + + # however, stud2 cannot access stud1's plan + stud2_req2 = factory.get('/course_plans/') + force_authenticate(stud2_req2, stud2.user) + res6 = view(stud2_req2, pk=plan1_res["id"]) + assert res6.status_code == status.HTTP_404_NOT_FOUND, \ + "An authenticated user cannot access another student's private plan" + + # nor can unauthenticated users access stud1's plan + unauth_req2 = factory.get('/course_plans/') + res7 = view(unauth_req2, pk=plan1_res["id"]) + assert res7.status_code == status.HTTP_404_NOT_FOUND, \ + "An unauthenticated user cannot access another student's private plan" diff --git a/Closure_Project/tests/test_models.py b/Closure_Project/tests/test_models.py index fb5cff79..8fac046a 100644 --- a/Closure_Project/tests/test_models.py +++ b/Closure_Project/tests/test_models.py @@ -12,4 +12,12 @@ def test_can_create_course(): course.save() course2 = models.Course.objects.get(course_id=13371337) - assert course2.name == "Software Testing" \ No newline at end of file + assert course2.name == "Software Testing" + +@pytest.mark.django_db +def test_user_creation_creates_student(): + user = models.User(username="Dummy") + user.save() + owner = models.Student.objects.filter(user=user) + assert len(owner) == 1 + print(owner)