├── criteria
    ├── assignment2.json
    ├── scipy.json
    ├── significant_figures.json
    ├── assignment1.json
    ├── plotting_data.json
    ├── numpy.json
    ├── general_test.json
    └── general.json
├── references.json
└── grading_template_json.html


/criteria/assignment2.json:
--------------------------------------------------------------------------------
 1 | {
 2 |    "codeFormatting":{
 3 |       "title":"Invalid Value",
 4 |       "additionalNotes":false,
 5 |       "negative":[
 6 |          {
 7 |             "mainPoint":"",
 8 |             "subPoints":[
 9 |                "Your value for the speed of light is incorrect!"
10 |             ]
11 |          }
12 |       ]
13 |    }
14 | }
15 | 


--------------------------------------------------------------------------------
/criteria/scipy.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "SciPy":{
 3 |         "title":"SciPy Library",
 4 |         "additionalNotes":true,
 5 |         "positive":[
 6 |         {
 7 |             "mainPoint":"",
 8 |             "subPoints":[
 9 |                 "Good job on using SciPy optimize function"
10 |             ]
11 |         }
12 |     ],
13 |         "negative":[
14 |         {
15 |             "mainPoint":"",
16 |             "subPoints":[
17 |                 "You needed to use SciPy's optimize function to find the optimal value of the variable."
18 |             ]
19 |         }
20 |     ]
21 |     }
22 | }


--------------------------------------------------------------------------------
/criteria/significant_figures.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "significantFigures":{
 3 |         "title":"Significant Figures",
 4 |         "additionalNotes":true,
 5 |         "positive":[
 6 |         {
 7 |             "mainPoint":"",
 8 |             "subPoints":[
 9 |                 "Your numbers are reported with the correct significant figures."
10 |             ]
11 |         }
12 |     ],
13 |         "negative":[
14 |         {
15 |             "mainPoint":"",
16 |             "subPoints":[
17 |                 "Your numbers have incorrect significant figures."
18 |             ]
19 |         }
20 |     ]
21 |     }
22 | }


--------------------------------------------------------------------------------
/criteria/assignment1.json:
--------------------------------------------------------------------------------
 1 | {
 2 |    "validValues":{
 3 |       "title":"Valid values",
 4 |       "additionalNotes":true,
 5 |       "positive":[
 6 |          {
 7 |             "mainPoint":"",
 8 |             "subPoints":[
 9 |                "Good job on checking whether the distance is negative."
10 |             ]
11 |          }
12 |       ],
13 |       "negative":[
14 |          {
15 |             "mainPoint":"",
16 |             "subPoints":[
17 |                "You did not check for negative values for the distance."
18 |             ]
19 |          }
20 |       ]
21 |    },
22 |    "wrongNumbers":{
23 |       "title":"Wrong Numbers",
24 |       "additionalNotes":false,
25 |       "negative":[
26 |          {
27 |             "mainPoint":"",
28 |             "subPoints":[
29 |                "The mass of the sun and/or the earth is wrong!"
30 |             ]
31 |          }
32 |       ]
33 |    }
34 | }
35 | 


--------------------------------------------------------------------------------
/criteria/plotting_data.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "plotting":{
 3 |         "title":"Plotting (Pandas or Matplotlib)",
 4 |         "additionalNotes":true,
 5 |         "positive":[
 6 |         {
 7 |             "mainPoint":"The plots were good regarding",
 8 |             "subPoints":[
 9 |                 "axis labels",
10 |                 "units",
11 |                 "line style",
12 |                 "line thickness",
13 |                 "point style",
14 |                 "point size",
15 |                 "title",
16 |                 "legend",
17 |                 "font size"
18 |             ]
19 |         }
20 |     ],
21 |         "negative":[
22 |         {
23 |             "mainPoint":"The following would have improved the plots",
24 |             "subPoints":[
25 |                 "axis labels",
26 |                 "units",
27 |                 "line style",
28 |                 "line thickness",
29 |                 "point style",
30 |                 "point size",
31 |                 "title",
32 |                 "legend",
33 |                 "font size"
34 |             ]
35 |         }
36 |     ]
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/references.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "generalCriteria":"https://raw.githubusercontent.com/karlkirschner/scipro_grading_testing/master/criteria/general.json",
 3 |     "assignmentSpecificCriteria":[
 4 |         {
 5 |             "id": 1,
 6 |             "title":"Significant Figures",
 7 |             "enabled": true,
 8 |             "url":"https://raw.githubusercontent.com/karlkirschner/scipro_grading_testing/master/criteria/significant_figures.json"
 9 |         },
10 |         {
11 |             "id": 2,
12 |             "title":"Plotting Data",
13 |             "enabled": true,
14 |             "url":"https://raw.githubusercontent.com/karlkirschner/scipro_grading_testing/master/criteria/plotting_data.json"
15 |         },
16 |         {
17 |             "id": 3,
18 |             "title":"NumPy",
19 |             "enabled": true,
20 |             "url":"https://raw.githubusercontent.com/karlkirschner/scipro_grading_testing/master/criteria/numpy.json"
21 |         },
22 |         {
23 |             "id": 4,
24 |             "title":"SciPy",
25 |             "enabled": true,
26 |             "url":"https://raw.githubusercontent.com/karlkirschner/scipro_grading_testing/master/criteria/scipy.json"
27 |         },
28 |         {
29 |             "id": 5,
30 |             "title":"GeneralTEST",
31 |             "enabled": true,
32 |             "url":"https://raw.githubusercontent.com/karlkirschner/scipro_grading_testing/master/criteria/general_test.json"
33 |         }
34 |     ]
35 | }
36 | 


--------------------------------------------------------------------------------
/criteria/numpy.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "numpy":{
 3 |         "title":"Numpy Library",
 4 |         "additionalNotes":true,
 5 |         "positive":[
 6 |         {
 7 |             "mainPoint":"The following points were well done",
 8 |             "subPoints":[
 9 |                 "good job on using ndarrays (simulated density and experimental value) for your Numpy function",
10 |                 "your Numpy function is indeed faster than your function using regular Python lists"
11 |             ]
12 |         }
13 |     ],
14 |         "neutral":[
15 |         {
16 |             "mainPoint":"The following points would improve the Numpy solution slightly",
17 |             "subPoints":[
18 |                 "the experimental value was passed as a float to your Numpy function, when converting to an ndarray object might have been better",
19 |                 "converting the Pandas' dataframe outside of your Numpy function might have improved its performance -- Remember to have a function that optimally does a single task",
20 |                 "please follow the standard practice within the community by importing Numpy as 'np'"
21 |             ]
22 |         }
23 |     ],
24 |         "negative":[
25 |         {
26 |             "mainPoint":"The following points need improvements",
27 |             "subPoints":[
28 |                 "for your Numpy function, you did not use ndarrays. Instead you passed the following data type to the function:",
29 |                 "iterating over the ndarray is not needed since it is vectorized, and results in a loss of performance",
30 |                 "your Numpy function should not be performing slower than your function that uses regular Python lists",
31 |                 "your function using Python lists has a performance of:",
32 |                 "your Numpy function has a performance of:"
33 |             ]
34 |         }
35 |     ]
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/criteria/general_test.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "GeneralTEST":{
 3 |         "title":"Academic Scholarship (Citations and Writing)",
 4 |         "additionalNotes":true,
 5 |         "positive":[
 6 |         {
 7 |             "mainPoint":"Good scholarship that includes the following",
 8 |             "subPoints":[
 9 |                 "citing source of information and knowledge",
10 |                 "excellent job on citations of important libraries and sources of knowledge",
11 |                 "consistent formatting of references"
12 |             ]
13 |         },
14 |         {
15 |             "mainPoint":"Good writing and communication that includes the following",
16 |             "subPoints":[
17 |                 "complete sentences used when appropriate (e.g. within Markdown cells)",
18 |                 "correct English spelling",
19 |                 "consistent usage of the English language (i.e. not mixing in non-English words)",
20 |                 "clean, concise and understandable sentences"
21 |             ]
22 |         },
23 |     ],
24 |         "neutral":[
25 |         {
26 |             "mainPoint":"Generally good citing of information, but with a few issues that include",
27 |             "subPoints":[
28 |                 "being careful when citing websites - when possible cite peer-reviewed papers or academic books",
29 |                 "when citing websites, one should include the date visited",
30 |                 "take care to provide the references with the same formatting structure"
31 |             ]
32 |         },
33 |         {
34 |             "mainPoint":"Generally good writing and communication, with the following small issues",
35 |             "subPoints":[
36 |                 "a few incomplete sentences when not appropriate (e.g. within Markdown cells)",
37 |                 "a few misspelled English words",
38 |                 "some mixing of English and German words",
39 |                 "a few sentences that were not concisely written or understandable"
40 |             ]
41 |         },
42 |     ],
43 |         "negative":[
44 |         {
45 |             "mainPoint":"No citation of information",
46 |             "subPoints":[
47 |                 "As a university student, you should be citing sources of knowledge. This is something that you will need to do for your thesis."
48 |             ]
49 |         },
50 |         {
51 |             "mainPoint":"Poorly citing information, which includes the following",
52 |             "subPoints":[
53 |                 "not citing Python3 libraries that were used:",
54 |                 "not citing sources for information used (e.g. equations, datasets):"
55 |             ]
56 |         },
57 |         {
58 |             "mainPoint":"No (or very little) communication of ideas or thoughts",
59 |             "subPoints":[
60 |                 "Communicating your thoughts and ideas is important (e.g. providing context for the code, clarification of workflow)."
61 |             ]
62 |         },
63 |         {
64 |             "mainPoint":"Poor writing and communication that includes the following",
65 |             "subPoints":[
66 |                 "no context given for what problem was being solved",
67 |                 "no presentation of thoughts or ideas concerning the workflow (or solution)",
68 |                 "lots of incomplete sentences when full sentences would have been appropriate ((e.g. within Markdown cells)",
69 |                 "several misspelled English words",
70 |                 "significant mixing of English and German words",
71 |                 "sentences were not concisely written, or not easily understood"
72 |             ]
73 |         }
74 |     ]
75 |     }
76 | }
77 | 


--------------------------------------------------------------------------------
/criteria/general.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "academicScholarship":{
  3 |         "title":"Academic Scholarship (Citations and Writing)",
  4 |         "additionalNotes":true,
  5 |         "positive":[
  6 |         {
  7 |             "mainPoint":"Good scholarship that includes the following",
  8 |             "subPoints":[
  9 |                 "citing source of information and knowledge",
 10 |                 "excellent job on citations of important libraries and sources of knowledge",
 11 |                 "consistent formatting of references"
 12 |             ]
 13 |         },
 14 |         {
 15 |             "mainPoint":"Good writing and communication that includes the following",
 16 |             "subPoints":[
 17 |                 "complete sentences used when appropriate (e.g. within Markdown cells)",
 18 |                 "correct English spelling",
 19 |                 "consistent usage of the English language (i.e. not mixing in non-English words)",
 20 |                 "clean, concise and understandable sentences"
 21 |             ]
 22 |         },
 23 |     ],
 24 |         "neutral":[
 25 |         {
 26 |             "mainPoint":"Generally good citing of information, but with a few issues that include",
 27 |             "subPoints":[
 28 |                 "being careful when citing websites - when possible cite peer-reviewed papers or academic books",
 29 |                 "when citing websites, one should include the date visited",
 30 |                 "take care to provide the references with the same formatting structure"
 31 |             ]
 32 |         },
 33 |         {
 34 |             "mainPoint":"Generally good writing and communication, with the following small issues",
 35 |             "subPoints":[
 36 |                 "a few incomplete sentences when not appropriate (e.g. within Markdown cells)",
 37 |                 "a few misspelled English words",
 38 |                 "some mixing of English and German words",
 39 |                 "a few sentences that were not concisely written or understandable"
 40 |             ]
 41 |         },
 42 |     ],
 43 |         "negative":[
 44 |         {
 45 |             "mainPoint":"No citation of information",
 46 |             "subPoints":[
 47 |                 "As a university student, you should be citing sources of knowledge. This is something that you will need to do for your thesis.",
 48 |             ]
 49 |         },
 50 |         {
 51 |             "mainPoint":"Poorly citing information, which includes the following",
 52 |             "subPoints":[
 53 |                 "not citing Python3 libraries that were used:",
 54 |                 "not citing sources for information used (e.g. equations, datasets):"
 55 |             ]
 56 |         },
 57 |         {
 58 |             "mainPoint":"No (or very little) communication of ideas or thoughts",
 59 |             "subPoints":[
 60 |                 "Communicating your thoughts and ideas is important (e.g. providing context for the code, clarification of workflow)."
 61 |             ]
 62 |         },
 63 |         {
 64 |             "mainPoint":"Poor writing and communication that includes the following",
 65 |             "subPoints":[
 66 |                 "no context given for what problem was being solved",
 67 |                 "no presentation of thoughts or ideas concerning the workflow (or solution)",
 68 |                 "lots of incomplete sentences when full sentences would have been appropriate ((e.g. within Markdown cells)",
 69 |                 "several misspelled English words",
 70 |                 "significant mixing of English and German words",
 71 |                 "sentences were not concisely written, or not easily understood"
 72 |             ]
 73 |         }
 74 |     ]
 75 |     },
 76 |     "jupyterNotebooks":{
 77 |         "title":"Jupyter Notebooks",
 78 |         "additionalNotes":true,
 79 |         "positive":[
 80 |         {
 81 |             "mainPoint":"Overall Notebook Structure",
 82 |             "subPoints":[
 83 |                 "Good use of cells structure to separate ideas (e.g. thoughts, tasks/subtasks, user-defined functions).",
 84 |                 "Good use of the Jupyter-notebook as a laboratory notebook.",
 85 |                 "Logical ordering and mixture of the markdown and code cells."
 86 |             ]
 87 |         },
 88 |         {
 89 |             "mainPoint":"Markdown Cells",
 90 |             "subPoints":[
 91 |                 "Good use of markdown cells to communicate the problem being investigated; your thoughts and ideas; or methodological workflow."
 92 |             ]
 93 |         }
 94 |     ],
 95 |         "neutral":[
 96 |         {
 97 |             "mainPoint":"Overall Notebook Structure",
 98 |             "subPoints":[
 99 |                 "Some separation concerning the tasks, subtasks, or ideas into different cells is seen in your solution. However, more could have been done to improve the notebook's organization and understanding."
100 |             ]
101 |         },
102 |         {
103 |             "mainPoint":"Markdown Cells",
104 |             "subPoints":[
105 |                 "Some markdown cells usage is demonstrated in your solution. However, including some more information would have improved the notebook's ability to convey your thoughts/ideas."
106 |             ]
107 |         }
108 |       ],
109 |         "negative":[
110 |         {
111 |             "mainPoint":"Overall Notebook Structure",
112 |             "subPoints":[
113 |                 "Significant work is needed to better separate the tasks, subtasks, or thoughts/ideas into separate cells for improving the notebook's organization and understanding."
114 |             ]
115 |         },
116 |         {
117 |             "mainPoint":"Markdown Cells",
118 |             "subPoints":[
119 |                 "Please provided more context through markdown cells that state the problem being investigated; your ideas and thoughts; or the methodological workflow."
120 |             ]
121 |         }
122 |     ]
123 |     },
124 |     "codeFormatting":{
125 |         "title":"Code Formatting",
126 |         "additionalNotes":true,
127 |         "positive":[
128 |         {
129 |             "mainPoint":"Very good code formatting that includes",
130 |             "subPoints":[
131 |                 "all libraries used were alphabetized",
132 |                 "all libraries used were listed at the top of the Jupyter-notebook",
133 |                 "consistent and correct use of spacing",
134 |                 "consistent and good use of blank lines (e.g. for separating ideas and improving readability)",
135 |                 "consistent and good indentation (i.e. 4 spaces)",
136 |                 "proper line lengths (e.g. no scrolling is needed)",
137 |                 "proper f-string statements",
138 |                 "descriptive object names (i.e. human readable)",
139 |                 "appropriate amount of block commenting done (i.e. # comment on its own line)",
140 |                 "appropriate amount of inline commenting done (i.e. # at the end of a code line)",
141 |                 "appropriate amount of docstrings done (i.e. using triple quotes)",
142 |                 "following PEP8 guidelines"
143 |             ]
144 |         }
145 |     ],
146 |         "negative":[
147 |         {
148 |             "mainPoint":"The following formatting issues were present in your code",
149 |             "subPoints":[
150 |                 "libraries were not alphabetized",
151 |                 "libraries were not listed at the top of the Jupyter-notebook",
152 |                 "spacing was inconsistent or incorrectly used",
153 |                 "blank lines were inconsistently used",
154 |                 "not enough blank lines were used to separate ideas within the code",
155 |                 "too many blank lines were used",
156 |                 "inconsistent or poor indentation (i.e. 4 spaces)",
157 |                 "coding lines were too long (i.e. requiring scrolling)",
158 |                 "coding lines were too short (i.e. deters from readability)",
159 |                 "f-string statements were not used",
160 |                 "object naming were not descriptive (i.e. human readable)",
161 |                 "block commenting (i.e. # on its own line) was not done, or there was poor usage of them",
162 |                 "in-line commenting (i.e. # at the end of a code line) was not done, or there was poor usage of them",
163 |                 "docstrings (i.e. using triple quotes) was not done, or there was poor usage of them",
164 |                 "excessive amounts of commenting done (e.g. for obvious points), or not relevant (i.e. singificantly distracts from the solution's main focus)",
165 |                 "following PEP8 guidelines"
166 |             ]
167 |         }
168 |     ]
169 |     },
170 |     "codingConcept":{
171 |         "title":"Coding Concept",
172 |         "additionalNotes":true,
173 |         "positive":[
174 |         {
175 |             "mainPoint":"Good use of data structures that includes",
176 |             "subPoints":[
177 |                 "dictionaries (e.g. my_dictionary = {key_1: value_1, key_2: value_2})",
178 |                 "sets (e.g. my_set = {item_1, item_2, item_3})",
179 |                 "tuples (e.g. my_tuple = (item_1, item_2, item_3))",
180 |                 "lists (e.g. my_list = [item_1, item_2, item_3])"
181 |             ]
182 |         },
183 |         {
184 |             "mainPoint":"Good use of the following coding concepts",
185 |             "subPoints":[
186 |                 "list comprehension",
187 |                 "looping over a dictionary",
188 |                 "looping over a set",
189 |                 "looping over a tuple",
190 |                 "looping over a list",
191 |                 "looping over two lists (with the same length) using the built-in function 'zip'",
192 |                 "the built-in function 'enumerate'",
193 |                 "the built-in function 'reversed'",
194 |                 "the built-in function 'sorted'"
195 |             ]
196 |         },
197 |     ],
198 |         "neutral":[
199 |         {
200 |             "mainPoint":"The following data structures issues could have been used, which might have made your code a bit better",
201 |             "subPoints":[
202 |                 "list comprehensions",
203 |                 "the use of a dictionary instead of a list",
204 |                 "the use of a tuple instead of a mutable list",
205 |                 "the use of 'zip' to loop over two lists of equal length"
206 |             ]
207 |         },
208 |     ],
209 |         "negative":[
210 |         {
211 |             "mainPoint":"The following data structures issues would have improved your code",
212 |             "subPoints":[
213 |                 "simplifying the list comprehension, or replacing with an 'if-elif-else' statements (i.e. to improve readability)",
214 |                 "the use of a dictionary instead of a list would have been logical",
215 |                 "the use of a tuple instead of a mutable list",
216 |                 "the use of 'zip' to loop over two lists of equal length"
217 |             ]
218 |         },
219 |         {
220 |             "mainPoint":"The following general concepts were problematic",
221 |             "subPoints":[
222 |                 "it is better to use 'if-elif-else' statements, rather than 'if-if-...' for readability and speed",
223 |                 "copy-and-pasting code introduces confusion and increases the chances of errors",
224 |                 "the code could have been more concisely formulated"
225 |             ]
226 |         }
227 |     ]
228 |     },
229 |     "userDefinedFunctions":{
230 |         "title":"User-defined Functions",
231 |         "additionalNotes":true,
232 |         "positive":[
233 |         {
234 |             "mainPoint":"Good use of the following",
235 |             "subPoints":[
236 |                 "including type hinting",
237 |                 "providing context via block comments",
238 |                 "stating what the function does",
239 |                 "stating what the input objects are (i.e. defined)",
240 |                 "stating what the function returns",
241 |                 "proving internal checks using 'if not isinstance' and a 'raise' statement",
242 |                 "setting an optional variable to a default value of 'None'",
243 |                 "isolating concepts well to user-defined functions (i.e. improving reusability, transferability and debugging)"
244 |             ]
245 |         }
246 |     ],
247 |         "neutral":[
248 |         {
249 |             "mainPoint":"The use of 'assert' over 'raise' statements",
250 |             "subPoints":[
251 |                 "It is better to use a 'raise' statement because 'assert' statements can be bypassed. Note that for development work, the use of 'assert' is okay."
252 |             ]
253 |         },
254 |         {
255 |             "mainPoint":"Too complex of a user-defined functions employed",
256 |             "subPoints":[
257 |                 "While it is good to have used a user-defined functions, the function itself does too much. It is better to isolate concepts into different functions, and to make the functions as general-purpose as possible."
258 |             ]
259 |         },
260 |     ],
261 |         "negative":[
262 |         {
263 |             "mainPoint":"No user-defined functions employed",
264 |             "subPoints":[
265 |                 "Your solution did not include user-defined functions. Defining your own function helps to isolate concepts, improves reusability, transferability and debugging. These are a major part of scientific programming."
266 |             ]
267 |         },
268 |         {
269 |             "mainPoint":"Your user-defined functions had the following problems",
270 |             "subPoints":[
271 |                 "a lack of type hinting",
272 |                 "incorrect type hinting",
273 |                 "no context given using docstring",
274 |                 "no statement about what the function does",
275 |                 "no statement about the input variables (i.e. defined)",
276 |                 "no statement about what the function returns",
277 |                 "no internal checks (i.e. 'if not isinstance' statements)",
278 |                 "not setting optional objects passed to a default value of 'None'",
279 |                 "when using 'if-elif-else' statements, the main part of the function should be nested under the else statement"
280 |             ]
281 |         }
282 |     ]
283 |     },
284 |     "callingFunction":{
285 |         "title":"Calling a Function",
286 |         "additionalNotes":true,
287 |         "negative":[
288 |         {
289 |             "mainPoint":"",
290 |             "subPoints":[
291 |                 "When calling a function, including your user-defined functions, one should reference the parameter that has an object being passed to it. For example, 'my_function(param1=a, param2=b)' and not 'my_function(a, b)'. Doing so ensure that the values are passed to the correct parameter."
292 |             ]
293 |         }
294 |     ]
295 |     },
296 |     "general":{
297 |         "title":"General Feedback",
298 |         "additionalNotes":true,
299 |         "positive":[
300 |         {
301 |             "mainPoint":"",
302 |             "subPoints":[
303 |                 "Excellent job on this assignment!",
304 |                 "Very good job on this assignment!",
305 |                 "Good job on this assignment."
306 |             ]
307 |         }
308 |     ],
309 |         "negative":[
310 |         {
311 |             "mainPoint":[
312 |                
313 |             ],
314 |             "subPoints":[
315 |                 "Your code does not run because of bad stuff:",
316 |                 "You used the following libraries that were not allowed in the assignment:",
317 |                 "You imported libraries that were unused -- this is confusing and cluters the code."
318 |             ]
319 |         }
320 |     ]
321 |     }
322 | }
323 | 


--------------------------------------------------------------------------------
/grading_template_json.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en">
  3 | 
  4 | <head>
  5 |     <meta charset="UTF-8">
  6 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  7 |     <link rel="preconnect" href="https://fonts.googleapis.com">
  8 |     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
  9 |     <link href="https://fonts.googleapis.com/css2?family=Roboto&display=swap" rel="stylesheet">
 10 |     <script src="https://code.jquery.com/jquery-3.6.0.min.js"
 11 |         integrity="sha256-/xUj+3OJU5yExlq6GSYGSHk7tPXikynS7ogEvDej/m4=" crossorigin="anonymous"></script>
 12 |     <script>
 13 |         const debug = false;
 14 |         let generalCriteria = {
 15 |     //Local testing:
 16 |     //    change `const debug = true` above
 17 |     //    copy-paste desire code to check locally below and reload HTML document
 18 |     "topic1":{
 19 |         "title":"Topic 1",
 20 |         "additionalNotes":true,
 21 |         "positive":[
 22 |         {
 23 |             "mainPoint":"1st positive feedback for topic 1",
 24 |             "subPoints":[
 25 |                 "Subpoint 1",
 26 |                 "Subpoint 2",
 27 |                 "Subpoint 3"
 28 |             ]
 29 |         },
 30 |         {
 31 |             "mainPoint":"2nd positive feedback for topic 1",
 32 |             "subPoints":[
 33 |                 "Point 1"
 34 |             ]
 35 |         }
 36 |     ],
 37 |         "neutral":[
 38 |         {
 39 |             "mainPoint":"1st netural feedback for topic 1",
 40 |             "subPoints":[
 41 |                 "Subpoint 1"
 42 |             ]
 43 |         },
 44 |       ],
 45 |         "negative":[
 46 |         {
 47 |             "mainPoint":"1st negative feedback for topic 1",
 48 |             "subPoints":[
 49 |                 "Subpoint 1",
 50 |                 "Subpoint 2 with comment box:"
 51 |             ]
 52 |         }
 53 |     ]
 54 |     },
 55 |     "topic2":{
 56 |         "title":"Topic 2",
 57 |         "additionalNotes":true,
 58 |         "positive":[
 59 |         {
 60 |             "mainPoint":"1st positive feedback for topic 2",
 61 |             "subPoints":[
 62 |                 "Subpoint 1",
 63 |                 "Subpoint 2",
 64 |                 "Subpoint 3"
 65 |             ]
 66 |         },
 67 |         {
 68 |             "mainPoint":"2nd positive feedback for topic 2",
 69 |             "subPoints":[
 70 |                 "Point 1"
 71 |             ]
 72 |         }
 73 |     ],
 74 |         "neutral":[
 75 |         {
 76 |             "mainPoint":"1st netural feedback for topic 2",
 77 |             "subPoints":[
 78 |                 "Subpoint 1"
 79 |             ]
 80 |         },
 81 |       ],
 82 |         "negative":[
 83 |         {
 84 |             "mainPoint":"1st negative feedback for topic 2",
 85 |             "subPoints":[
 86 |                 "Subpoint 1",
 87 |                 "Subpoint 2 with comment box:"
 88 |             ]
 89 |         }
 90 |     ]
 91 |     }
 92 | }
 93 | 
 94 |         if (!debug) {
 95 |             var specificCriteria = []
 96 | 
 97 |             $.ajax({
 98 |                 dataType: "json",
 99 |                 url: "https://raw.githubusercontent.com/karlkirschner/scipro_grading_testing/master/references.json",
100 |                 success: function (data) {
101 |                     $.ajax({
102 |                         dataType: "json",
103 |                         url: data.generalCriteria,
104 |                         success: function (data) {
105 |                             generalCriteria.content = data;
106 |                         },
107 |                         complete: function () {
108 |                             var promises = [];
109 |                             for (const assignment of data.assignmentSpecificCriteria) {
110 |                                 if (assignment.enabled) {
111 |                                     const request = $.ajax({
112 |                                         dataType: "json",
113 |                                         url: assignment.url,
114 |                                         success: function (data) {
115 |                                             assignment.content = data;
116 |                                             specificCriteria.push(assignment);
117 |                                         }
118 |                                     });
119 |                                     promises.push(request);
120 |                                 }
121 |                             }
122 |                             Promise.all(promises).then(function () {
123 |                                 specificCriteria.sort((a, b) => { return a.id - b.id });
124 |                                 generateTemplate(generalCriteria, specificCriteria);
125 |                             }).catch(err => console.log(err));
126 |                         }
127 |                     });
128 |                 },
129 |             });
130 |         }
131 | 
132 | 
133 | 
134 | 
135 |     </script>
136 | 
137 |     <title>Scientific Python - Grading template</title>
138 |     <!--CSS code for a floating box for grades-->
139 |     <style>
140 |         body {
141 |             background-color: #FAFAFA;
142 |         }
143 | 
144 |         * {
145 |             font-family: 'Roboto', sans-serif;
146 |         }
147 | 
148 |         .side {
149 |             border-radius: 5px;
150 |             width: 300px;
151 |             border: 1px solid;
152 |             background-color: #ADD8E6;
153 |             min-height: 200px;
154 |             position: fixed;
155 |             padding: 5px;
156 |             right: 55px;
157 |             top: 200px;
158 |         }
159 | 
160 |         ul {
161 |             list-style: none;
162 |         }
163 | 
164 |         input[type=number]::-webkit-inner-spin-button {
165 |             opacity: 1
166 |         }
167 | 
168 |         table,
169 |         th,
170 |         td {
171 |             border: 1px solid black;
172 |         }
173 | 
174 |         .button {
175 |             border: none;
176 |             color: white;
177 |             padding: 15px 32px;
178 |             text-align: center;
179 |             text-decoration: none;
180 |             display: inline-block;
181 |             font-size: 16px;
182 |             cursor: pointer;
183 |             margin-left: 3rem;
184 |         }
185 | 
186 |         .reset-button {
187 |             background-color: #f44336;
188 |         }
189 | 
190 |         .generate-button {
191 |             background-color: rgb(88, 184, 243);
192 |             margin-bottom: 5rem;
193 |             margin-top: 5rem;
194 |         }
195 | 
196 |         .save-button {
197 |             background-color: rgb(79, 212, 79);
198 |         }
199 | 
200 |         .button-box {
201 |             display: table;
202 |             margin: 0 auto;
203 |         }
204 | 
205 |         .button:active {
206 |             box-shadow: rgba(50, 50, 93, 0.25) 0px 30px 60px -12px inset, rgba(0, 0, 0, 0.3) 0px 18px 36px -18px inset;
207 |         }
208 | 
209 |         ul {
210 |             margin: 2px;
211 |             margin-left: 2rem;
212 |         }
213 | 
214 |         .category-title {
215 |             font-size: 22px;
216 |             font-weight: bolder;
217 |             margin: 0;
218 |             margin-bottom: 2rem;
219 |         }
220 | 
221 |         .mainpoint-label {
222 |             font-size: 1rem;
223 |             font-weight: bolder;
224 |             margin-top: 1rem;
225 |             margin-bottom: 0.5rem;
226 |             margin-left: 2rem;
227 |         }
228 | 
229 |         .category {
230 |             margin-top: 3rem;
231 |             margin-left: 3rem;
232 |             margin-right: 3rem;
233 |             margin-bottom: 3rem;
234 |             padding-left: 3rem;
235 |             padding-right: 3rem;
236 |             padding-top: 2rem;
237 |             padding-bottom: 2rem;
238 |             background-color: #FFFFFF;
239 |             border-radius: 25px;
240 |             box-shadow: rgba(0, 0, 0, 0.35) 0px 5px 15px;
241 |         }
242 | 
243 |         .positive {
244 |             color: blue;
245 |             font-size: 1.3rem;
246 |             font-weight: bolder;
247 |             margin-bottom: 0px;
248 |         }
249 | 
250 |         .neutral {
251 |             margin-top: 1.3rem;
252 |             color: green;
253 |             font-size: 1.3rem;
254 |             font-weight: bolder;
255 |             margin-bottom: 0px;
256 |         }
257 | 
258 |         .negative {
259 |             margin-top: 1.3rem;
260 |             color: red;
261 |             font-size: 1.3rem;
262 |             font-weight: bolder;
263 |             margin-bottom: 0px;
264 |         }
265 | 
266 |         .subpoint-textbox {
267 |             margin-left: 1.2rem;
268 |             margin-bottom: 1rem;
269 |             display: block;
270 | 
271 |         }
272 | 
273 |         .textarea-container {
274 |             margin-left: 5rem;
275 |             margin-right: 5rem;
276 |             margin-bottom: 5rem;
277 |             height: 600px;
278 |         }
279 | 
280 |         #textarea-evaluation {
281 |             width: 100%;
282 |             height: 100%;
283 |             padding: 12px 20px;
284 |             box-sizing: border-box;
285 |             border: 2px solid #ccc;
286 |             border-radius: 4px;
287 |             background-color: #f8f8f8;
288 |             font-size: 16px;
289 |         }
290 | 
291 |         .textarea-notes {
292 |             width: 70%;
293 |             height: 150px;
294 |             margin-left: 5rem;
295 |         }
296 | 
297 |         .tabs {
298 |             overflow: hidden;
299 |             border: 1px solid #ccc;
300 |             background-color: #f1f1f1;
301 |         }
302 | 
303 |         .tabs button {
304 |             background-color: inherit;
305 |             float: left;
306 |             border: none;
307 |             outline: none;
308 |             cursor: pointer;
309 |             padding: 14px 16px;
310 |             transition: 0.3s;
311 |             font-size: 17px;
312 |         }
313 | 
314 |         .tabs button:hover {
315 |             background-color: #ddd;
316 |         }
317 | 
318 |         .tabs button.active {
319 |             background-color: #ccc;
320 |         }
321 | 
322 |         .assignment-specific-title {
323 |             margin-left: 5rem;
324 |         }
325 | 
326 |         .assignment-section-title {
327 |             margin-left: 5rem;
328 |         }
329 |     </style>
330 | </head>
331 | 
332 | <body>
333 |     <header>
334 |         <center>
335 |             <h1>Scientific Programming for Python</h1>
336 |             <h2>Grading Template</h2>
337 |             <p>The goal of this form is 1) enable faster grading and 2) unifies the feedback given to the students due
338 |                 to multiple graders.</p>
339 |             <center />
340 |     </header>
341 | 
342 |     <div class="side">
343 |         <b>Grading</b>
344 |         <table style="width:100%">
345 |             <tr>
346 |                 <td>Code quality & design</td>
347 |                 <td><input type="number" value="6" min="0.0" max="6.0" step="0.5"></td>
348 |             </tr>
349 | 
350 |             <tr>
351 |                 <td>Code excution & results</td>
352 |                 <td><input type="number" value="6" min="0.0" max="6.0" step="0.5"></td>
353 |             </tr>
354 | 
355 |             <tr>
356 |                 <td>Assignment requirements</td>
357 |                 <td><input type="number" value="6" min="0.0" max="6.0" step="0.5"></td>
358 |             </tr>
359 | 
360 |             <tr>
361 |                 <td>Scientific programming</td>
362 |                 <td><input type="number" value="6" min="0.0" max="6.0" step="0.5"></td>
363 |             </tr>
364 | 
365 |             <tr>
366 |                 <td>Creativity</td>
367 |                 <td><input type="number" value="4" min="0.0" max="4.0" step="0.5"></td>
368 |             </tr>
369 |         </table>
370 |     </div>
371 | 
372 |     <script>
373 |         // ================ Object descriptions ==================
374 | 
375 |         /** === assignmentSpecificCriteria {assignmentObject[]} ===
376 |          * An array containing multiple assignment objects.
377 |          */
378 | 
379 |         /** === assignmentObject {object} ===
380 |          * @attribute {number} id - The id representing the order of the assignment.
381 |          * @attribute {string} title - The title of the assignment.
382 |          * @attribute {boolean} enabled - Whether the assignment template should be available to the grader.
383 |          * @attribute {string} url - The url to the raw format of the assignment.json (The assignment.json are of type generalCriteria)
384 |          * @attribute {generalCriteria} content - This will be automatically added via the code. Content is a generalCriteria objects related to the assignment.
385 | 
386 |         /** === generalCriteria {object} ===
387 |         * An object which contains multiple categories {category}
388 |         */
389 | 
390 |         /** === category {object} ===
391 |         * @attribute {string} title - The title of the category.
392 |         * @attribute {boolean} additionalNotes - Whether the category should have a textarea at the bottom of the category for additional notes.
393 |         * @attribute {mainPoint[]} positive - A list of positive mainPoint objects.
394 |         * @attribute {mainPoint[]} neutral - A list of neutral mainPoint objects.
395 |         * @attribute {mainPoint[]} negative - A list of negative mainPoint objects.
396 |         */
397 | 
398 |         /** === mainPoint {object} ===
399 |         * @attribute {string} mainPoint - The label of the mainPoint.
400 |         * @attribute {string[]} subPoints - A list of the subPoints in relation to the mainPoint. (If a subPoint ends with a ":" an additional textfield will be generated.)
401 |         */
402 | 
403 |         // =======================================================================
404 | 
405 |         // This id is used for indexing the subPoints for easier storage and loading.
406 |         var idCount = 0;
407 | 
408 | 
409 |         // This method will load the generalCriteria object defined in this JavaScript code.
410 |         if (debug) {
411 |             generateTemplate(generalCriteria);
412 |         }
413 | 
414 |         /**
415 |          * Generates the template for the grading form. Main entry to create the forms.
416 |          * @param {object} generalCriteria - The general criteria for the assignment. A form dictionary/object.
417 |          * @param {object} specificCriteria - An array of objects containing a form dictionary/object with it's metadata for each assignment.
418 |          */
419 | 
420 |         function generateTemplate(generalCriteria, assignmentSpecificCriteria = []) {
421 | 
422 |             // Generates "Reset" button
423 |             document.body.appendChild(generateButton("Reset", reset, ["button", "reset-button"]));
424 | 
425 |             // Generates categories 
426 |             for (const category in generalCriteria) {
427 |                 const container = generateCategory(generalCriteria[category], category);
428 |                 document.body.appendChild(container);
429 |             }
430 | 
431 |             // Generates library/assignment specific forms if available
432 |             if (assignmentSpecificCriteria.length > 0) {
433 |                 const sectionTitle = document.createElement("h1");
434 |                 sectionTitle.innerText = "Library and Assignment Specific Feedback";
435 |                 sectionTitle.classList.add("assignment-section-title")
436 |                 document.body.appendChild(sectionTitle);
437 |                 generateTabs(assignmentSpecificCriteria);
438 |             }
439 | 
440 |             // Generates the "Generate" and "Save" buttons
441 |             const buttonBox = document.createElement("div");
442 |             buttonBox.classList.add("button-box");
443 |             buttonBox.appendChild(generateButton("Generate", evaluate, ["button", "generate-button"]));
444 |             buttonBox.appendChild(generateButton("⠀ Save ⠀", save, ["button", "save-button"]));
445 |             document.body.appendChild(buttonBox);
446 | 
447 |             // Generates the textarea containing all checked points for the evaluation.
448 |             const textAreaContainer = document.createElement("div");
449 |             textAreaContainer.classList.add("textarea-container");
450 |             const textArea = document.createElement("textarea");
451 |             textArea.classList.add("textarea-evaluation")
452 |             textArea.id = "textarea-evaluation";
453 |             textAreaContainer.appendChild(textArea);
454 |             document.body.appendChild(textAreaContainer);
455 | 
456 |             // Loads data which are stored in the LocalStorage
457 |             loadLocalStorage(generalCriteria, assignmentSpecificCriteria);
458 |         }
459 | 
460 |         /**
461 |          * Generates button given a label, a function and classes.
462 |          * @param {string} label - The text to be displayed on the button
463 |          * @param {function} clickFunction - The function to be executed after clicked.
464 |          * @param {string[]} classList - A list of strings containing the class names
465 |          * @return {button} button - A button.
466 |          */
467 |         function generateButton(label, clickFunction, classList) {
468 |             const button = document.createElement("button");
469 |             button.innerText = label;
470 |             button.onclick = clickFunction;
471 | 
472 |             for (const classLabel of classList) {
473 |                 button.classList.add(classLabel);
474 |             }
475 |             return button;
476 |         }
477 | 
478 |         /**
479 |          * Generates a category, using a category object and the title of the category for the additional field creation.
480 |          * @param {category} data - An category object.
481 |          * @param {string} category - The title of the category.
482 |          * @return {div} container - A container containing the category.
483 |          */
484 |         function generateCategory(data, category) {
485 |             // Generate category container
486 |             const container = document.createElement("div");
487 |             container.classList.add("category")
488 | 
489 |             // Add title to category container
490 |             const title = document.createElement("p");
491 |             title.innerText = data["title"];
492 |             title.classList.add("category-title")
493 |             container.appendChild(title);
494 | 
495 |             // Generate container containing positive, neutral and negative mainPoints.
496 |             const criteriaContainer = document.createElement("div");
497 |             criteriaContainer.classList.add("criteria");
498 |             container.append(criteriaContainer);
499 | 
500 |             // Generates the mainPoints with it's subPoints for each criteria.
501 |             for (const criteria of ["positive", "neutral", "negative"]) {
502 |                 if (Object.keys(data).includes(criteria)) {
503 |                     generateCriteria(criteriaContainer, data, criteria);
504 |                 }
505 |             }
506 |             
507 |             // Generates the textarea of the corresponding category
508 |             if (data["additionalNotes"]) {
509 |                 const title = document.createElement("p");
510 |                 title.innerText = "Additional Notes:";
511 |                 title.classList.add("mainpoint-label");
512 |                 container.appendChild(title);
513 |                 container.appendChild(generateAdditionalNotesArea(category));
514 |             }
515 |             return container;
516 |         }
517 | 
518 |         /**
519 |          * Generate the mainPoints.
520 |          * @param {div} container - The container which the mainPoints will be added to.
521 |          * @param {mainPoint[]} data - A list containing mainPoint objects.
522 |          * @param {string} criteria - The criteria positive or neutral or negative, which are also keys of the corresponding category object.
523 |          */
524 |         function generateCriteria(container, data, criteria) {
525 |             // Generate criteria container
526 |             const title = document.createElement("p");
527 |             title.classList.add(criteria)
528 |             title.innerText = criteria[0].toUpperCase() + criteria.slice(1) + ":";
529 |             container.appendChild(title);
530 | 
531 |             for (element of data[criteria]) {
532 |                 generateMainPoint(container, element, criteria);
533 |             }
534 | 
535 |         };
536 | 
537 |         /**
538 |          * Generate the mainPoint.
539 |          * @param {div} container - The container which the mainPoint will be added to.
540 |          * @param {mainPoint} data - An mainPoint object
541 |          * @param {string} criteria - The criteria positive or neutral or negative, which are also keys of the corresponding category object.
542 |          */
543 |         function generateMainPoint(container, element, criteria) {
544 |             // Generate mainPoint
545 |             const label = document.createElement("p");
546 |             label.innerText = element["mainPoint"];
547 |             label.classList.add("mainpoint-label")
548 |             container.appendChild(label);
549 | 
550 |             // Generate subPoints
551 |             const subPoints = generateSubPoints(container, element["subPoints"], criteria)
552 |             container.appendChild(subPoints);
553 |         };
554 | 
555 |         /**
556 |          * Generate the subPoints.
557 |          * @param {div} container - The container which the subPoints will be added to.
558 |          * @param {string[]} subPoints - An list of strings representing the subPoints.
559 |          * @param {string} criteria - The criteria positive or neutral or negative, which are also keys of the corresponding category object.
560 |          * @return {div} subPointContainer - A div containing the subPoints.
561 |          */
562 |         function generateSubPoints(container, subPoints, criteria) {
563 |             // Generate subPoint container
564 |             const subPointContainer = document.createElement("div");
565 |             subPointContainer.id = "subPoint-" + criteria + "-" + idCount;
566 |             idCount++;
567 | 
568 |             // Generate subPoints
569 |             const unorderedList = document.createElement("ul");
570 |             for (const subPoint of subPoints) {
571 |                 const listElement = document.createElement("li");
572 |                 const checkBox = document.createElement("input");
573 |                 checkBox.type = "checkbox";
574 |                 checkBox.value = subPoint;
575 |                 checkBox.id = idCount;
576 | 
577 |                 const label = document.createElement("label");
578 |                 label.htmlFor = idCount++;
579 |                 label.innerText = subPoint;
580 | 
581 |                 listElement.appendChild(checkBox);
582 |                 listElement.appendChild(label);
583 | 
584 |                 // Add textbox if subPoint ends with ":" or ": "
585 |                 if (subPoint.endsWith(":") || subPoint.endsWith(": ")) {
586 |                     const textBox = generateSubPointTextBox(subPoint);
587 |                     listElement.appendChild(textBox);
588 |                 }
589 | 
590 |                 unorderedList.appendChild(listElement);
591 |             }
592 |             subPointContainer.appendChild(unorderedList);
593 |             return subPointContainer;
594 |         }
595 | 
596 |         /**
597 |          * Generate a text field for a subPoint.
598 |          * @param {string} subPoint - A string representing the subPoint.
599 |          * @return {textArea} textBox - A textArea corresponding to the given subPoint.
600 |          */
601 |         function generateSubPointTextBox(subPoint) {
602 |             const textBox = document.createElement("textarea");
603 |             textBox.classList.add("subpoint-textbox");
604 |             textBox.type = "text";
605 |             textBox.id = subPoint;
606 |             return textBox;
607 |         }
608 | 
609 |         /**
610 |          * Generate a text field for a subPoint.
611 |          * @param {string} subPoint - A string representing the subPoint.
612 |          * @return {textArea} textArea - A textArea corresponding to the given category.
613 |          */
614 |         function generateAdditionalNotesArea(category) {
615 |             const textArea = document.createElement("textarea");
616 |             textArea.id = category;
617 |             textArea.classList.add("textarea-notes");
618 |             return textArea;
619 |         }
620 | 
621 |         /**
622 |          * Cleares the local storage and saves the data in the forms to the local storage
623 |          */
624 |         function save() {
625 |             window.localStorage.clear();
626 | 
627 |             // Save values of the checkboxes
628 |             const allInputs = document.querySelectorAll('input[type="checkbox"]:checked');
629 |             for (const input of allInputs) {
630 |                 localStorage.setItem(input.id, "checked");
631 |             }
632 | 
633 |             // Save values of the category textareas.
634 |             const allTextNotes = document.querySelectorAll(".textarea-notes");
635 |             for (const textNote of allTextNotes) {
636 |                 if (textNote.value.length > 0)
637 |                     localStorage.setItem(textNote.id, textNote.value);
638 |             }
639 | 
640 |             // Save values of the subPoint textboxes.
641 |             const allSubPoinTextBox = document.querySelectorAll(".subpoint-textbox");
642 |             for (const textBox of allSubPoinTextBox) {
643 |                 if (textBox.value.length > 0)
644 |                     localStorage.setItem(textBox.id, textBox.value);
645 |             }
646 | 
647 |             // Save the textarea containing all checked checkboxes (Filled after "Generate")
648 |             const textArea = document.getElementById("textarea-evaluation");
649 |             if (textArea.value.length > 0) {
650 |                 localStorage.setItem("textarea-evaluation", textArea.value);
651 |             }
652 | 
653 |             alert("Saved!")
654 |         }
655 | 
656 |         /**
657 |          * Loads the local storage. If debug mode is given the local storage will be cleared instead.
658 |          * @param {generalCriteria} generalCriteria - An generalCriteria object.
659 |          * @param {assignmentObject[]} - An array containing multiple assignment objects
660 |          */
661 |         function loadLocalStorage(generalCriteria, assignmentSpecificCriteria) {
662 |             if (debug) {
663 |                 localStorage.clear();
664 |             }
665 | 
666 |             // Load checkboxes from local storage
667 |             for (const key in localStorage) {
668 |                 if (key.match("^[0-9]*$")) {
669 |                     const checkBox = document.getElementById(key);
670 |                     checkBox.checked = true;
671 |                 }
672 |             }
673 | 
674 |             // Load evaluation textbox from local storage
675 |             const textAreaStorageValue = localStorage.getItem("textarea-evaluation")
676 |             if (textAreaStorageValue !== undefined) {
677 |                 document.getElementById("textarea-evaluation").value = textAreaStorageValue;
678 |             }
679 | 
680 |             // Load textareas from the categories of the generalCriteria object
681 |             for (const key of Object.keys(generalCriteria)) {
682 |                 const textAreaNoteValue = localStorage.getItem(key);
683 |                 document.getElementById(key).value = textAreaNoteValue;
684 |             }
685 | 
686 |             // Load textareas from the list of assignmentObjects
687 |             for (const assignment of assignmentSpecificCriteria) {
688 |                 for (const key of Object.keys(assignment.content)) {
689 |                     const storageValue = localStorage.getItem(key);
690 |                     const textArea = document.getElementById(key);
691 |                     
692 |                     if(textArea){
693 |                         textArea.value = storageValue;
694 |                     }
695 |                 }
696 |             }
697 | 
698 |             // Load textareas from subPoints
699 |             for (const key in localStorage) {
700 |                 if (key.endsWith(":") || key.endsWith(": ")) {
701 |                     const subPointTextBoxValue = localStorage.getItem(key);
702 |                     document.getElementById(key).value = subPointTextBoxValue;
703 |                 }
704 |             }
705 |         }
706 | 
707 | 
708 |         /**
709 |          * Clears local storage and remove all inputs
710 |          */
711 |         function reset() {
712 |             const allInputs = document.querySelectorAll('input[type="checkbox"]:checked');
713 |             const allTextAreaNotes = document.querySelectorAll(".textarea-notes")
714 |             const allSubPoinTextBox = document.querySelectorAll(".subpoint-textbox");
715 | 
716 |             window.localStorage.clear();
717 |             document.getElementById("textarea-evaluation").value = "";
718 | 
719 |             for (const input of allInputs) {
720 |                 input.checked = false;
721 |             }
722 | 
723 |             for (const textNotes of allTextAreaNotes) {
724 |                 textNotes.value = "";
725 |             }
726 | 
727 |             for (const subPointTextBox of allSubPoinTextBox) {
728 |                 subPointTextBox.value = "";
729 |             }
730 | 
731 |         }
732 | 
733 |         /**
734 |          * If a string contains multiple lines. Add indentation to all of those lines.
735 |          * @param {string} text - A multi-line text to be indented.
736 |         */
737 |         function multiLineIndent(text) {
738 |             let newText = "";
739 |             for (const line of text.split("\n")) {
740 |                 newText += "          " + line + "\n";
741 |             }
742 |             return newText;
743 |         }
744 | 
745 |         /**
746 |          * Entrypoint to the evaluation text of the template.
747 |         */
748 |         function evaluate() {
749 |             const firstEvaluation = generateEvaluation(generalCriteria, "GENERAL NOTES\n\n");
750 | 
751 |             const activeTab = document.querySelector(".active.tab");
752 |             for (const assignment of specificCriteria) {
753 |                 if (activeTab && assignment.title === activeTab.id) {
754 |                     generateEvaluation(assignment.content, firstEvaluation + "\nASSIGNMENT SPECIFIC NOTES\n\n");
755 |                 }
756 |             }
757 |         }
758 | 
759 |         /**
760 |          * Given a generalCriteria object create a text containing all checked checkboxes with it's notes.
761 |          * @param {generalCriteria} data - An general criteria object.
762 |          * @param {string} previousEvaluation - A string, that will be prepended to the generated text.
763 |          */
764 |         function generateEvaluation(data, previousEvaluation = "") {
765 |             const allInputs = document.querySelectorAll('input[type="checkbox"]:checked');
766 |             const values = []
767 |             for (const input of allInputs) {
768 |                 values.push(input.value);
769 |             }
770 | 
771 |             evaluationText = previousEvaluation;
772 | 
773 |             for (const category in data) {
774 |                 // Flags to determine whether the text contains these information.
775 |                 let alreadyAddedCategory = false;
776 |                 let alreadyAddedPositive = false;
777 |                 let alreadyAddedNeutral = false;
778 |                 let alreadyAddedNegative = false;
779 | 
780 |                 for (const criteria of ["positive", "neutral", "negative"]) {
781 |                     let alreadyAddedMainPoint = false;
782 | 
783 |                     if (Object.keys(data[category]).includes(criteria)) {
784 |                         for (const element of data[category][criteria]) {
785 |                             for (const subPoint of element["subPoints"]) {
786 | 
787 |                                 if (values.includes(subPoint)) {
788 |                                     if (!alreadyAddedCategory) {
789 |                                         evaluationText += data[category]["title"] + "\n";
790 |                                         alreadyAddedCategory = true;
791 |                                     }
792 |                                     if (criteria === "positive" && !alreadyAddedPositive) {
793 |                                         evaluationText += "\nPositive:\n";
794 |                                         alreadyAddedPositive = true;
795 |                                     }
796 |                                     if (criteria === "neutral" && !alreadyAddedNeutral) {
797 |                                         evaluationText += "\nNeutral:\n";
798 |                                         alreadyAddedNeutral += true;
799 |                                     }
800 |                                     if (criteria === "negative" && !alreadyAddedNegative) {
801 |                                         evaluationText += "\nNegative:\n";
802 |                                         alreadyAddedNegative += true;
803 |                                     }
804 |                                     if (!alreadyAddedMainPoint && element["mainPoint"].length > 0) {
805 |                                         evaluationText += "  - " + element["mainPoint"] + ":\n";
806 |                                         alreadyAddedMainPoint += true;
807 |                                     }
808 |                                     evaluationText += "      - " + subPoint + "\n";
809 |                                     if (subPoint.endsWith(":") || subPoint.endsWith(": ")) {
810 |                                         textBoxValue = multiLineIndent(document.getElementById(subPoint).value);
811 |                                         evaluationText += textBoxValue;
812 |                                     }
813 |                                 }
814 |                             }
815 |                         }
816 |                     }
817 |                 }
818 | 
819 |                 const textNotes = document.getElementById(category)
820 | 
821 |                 if (textNotes && textNotes.value.length > 0) {
822 |                     if (!alreadyAddedCategory) {
823 |                         evaluationText += data[category]["title"] + "\n";
824 |                         alreadyAddedCategory = true;
825 |                     }
826 | 
827 |                     evaluationText += "\nAdditional Notes:\n";
828 |                     evaluationText += textNotes.value + "\n";
829 |                 }
830 | 
831 |                 if (alreadyAddedCategory) {
832 |                     evaluationText += "\n\n";
833 |                 }
834 |             }
835 |             document.getElementById("textarea-evaluation").value = evaluationText;
836 |             return evaluationText;
837 |         }
838 | 
839 |         /**
840 |          * Generate the assignment tabs. With it's content.
841 |          * @param {assignmentObject[]} assignmentSpecificCriteria - An array containing assignment objects.
842 |          */
843 |         function generateTabs(assignmentSpecificCriteria) {
844 |             // Generate the main tabs container
845 |             const tabs = document.createElement("div");
846 |             tabs.classList.add("tab-container");
847 |             const tabContentRoot = document.createElement("div");
848 |             tabs.classList.add("tabs");
849 | 
850 |             function toogleTab(id) {
851 |                 selectedTabContent = document.getElementById(id + " - content");
852 |                 selectedButton = document.getElementById(id);
853 | 
854 |                 buttons = document.querySelectorAll(".tab");
855 |                 tabContents = document.querySelectorAll(".tab-content");
856 | 
857 |                 for (const tabContent of tabContents) {
858 |                     tabContent.style.display = "none";
859 |                     tabContent.classList.remove("active");
860 |                 }
861 | 
862 |                 for (const button of buttons) {
863 |                     button.classList.remove("active");
864 |                 }
865 | 
866 |                 if (!selectedButton.classList.contains("active")) {
867 |                     selectedTabContent.style.display = "block";
868 |                     selectedButton.classList.add("active");
869 |                 }
870 |             }
871 | 
872 |             // Generate the assignment content.
873 |             for (const key in Object.keys(assignmentSpecificCriteria)) {
874 |                 const assignment = assignmentSpecificCriteria[key];
875 | 
876 |                 // Generate the assignment content container
877 |                 const tabContentContainer = document.createElement("div");
878 |                 tabContentContainer.id = assignment["title"] + " - content";
879 |                 tabContentContainer.style.display = "none";
880 |                 const title = document.createElement("h2");
881 |                 title.classList.add("assignment-specific-title");
882 |                 title.innerText = assignment["title"];
883 |                 tabContentContainer.appendChild(title);
884 |                 tabContentContainer.classList.add("tab-content");
885 |                 for (const category in assignment["content"]) {
886 |                     const container = generateCategory(assignment["content"][category], category);
887 |                     tabContentContainer.appendChild(container);
888 |                 }
889 | 
890 |                 // Generate the tab corresponding to the assignment content.
891 |                 const tab = document.createElement("button");
892 |                 tab.innerHTML = assignment["title"];
893 |                 tab.id = assignment["title"];
894 |                 tab.classList.add("tab");
895 |                 tab.addEventListener("click", () => {
896 |                     toogleTab(tab.id);
897 |                 });
898 | 
899 | 
900 |                 tabs.appendChild(tab);
901 |                 tabContentRoot.appendChild(tabContentContainer);
902 |             }
903 |             document.body.appendChild(tabs);
904 |             document.body.appendChild(tabContentRoot);
905 |         }
906 | 
907 | 
908 |     </script>
909 | 
910 | </body>
911 | 
912 | </html>


--------------------------------------------------------------------------------