diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..27dda55 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +.DS_Store +*.autosave +*.orig* +*~ +*.o +*.pyc +*.aux +*.log +*.out +*.synctex.gz diff --git a/MakefileHelper b/MakefileHelper new file mode 100644 index 0000000..3675029 --- /dev/null +++ b/MakefileHelper @@ -0,0 +1,153 @@ +.PHONY: default pull push all compile overall section lab hw test quiz final iclicker zone clean src_clean remove_json_comments + +default: overall + +# ============================================================================= +# This is the helper Makefile + +# Don't directly use this Makefile, it should be included from the +# per-course Makefile with these variables set: + +ifndef USERNAME +$(error Variable USERNAME not set) +endif + +ifndef RAINBOW_GRADES_DIRECTORY +$(error Variable RAINBOW_GRADES_DIRECTORY not set) +endif + +ifndef HWSERVER +$(error Variable HWSERVER not set) +endif + +ifndef REPORTS_DIRECTORY +$(error Variable REPORTS_DIRECTORY not set) +endif + +GRADING_DIRECTORY := $(RAINBOW_GRADES_DIRECTORY)/../grading + + +nlohmann_json_dir=${RAINBOW_GRADES_DIRECTORY}/../vendor/nlohmann/json + +${nlohmann_json_dir}: + mkdir -p ${nlohmann_json_dir} + wget https://github.com/nlohmann/json/releases/download/v3.1.2/include.zip -O ${RAINBOW_GRADES_DIRECTORY}/../vendor/nlohmann_json.zip + unzip -o ${RAINBOW_GRADES_DIRECTORY}/../vendor/nlohmann_json.zip -d ${nlohmann_json_dir} + + +# Grab this file from the main Submitty repo +json_syntax_checker.py = ${RAINBOW_GRADES_DIRECTORY}/../misc_tools/json_syntax_checker.py +${json_syntax_checker.py}: + mkdir -p ${RAINBOW_GRADES_DIRECTORY}/../misc_tools/ + wget https://raw.githubusercontent.com/Submitty/Submitty/master/grading/json_syntax_checker.py -O ${json_syntax_checker.py} + + +# ============================================================================= + +pull: + mkdir -p raw_data/ + rsync -azP ${USERNAME}@${HWSERVER}:${REPORTS_DIRECTORY}/all_grades/ raw_data/ + +push: + rsync -azP individual_summary_html/* ${USERNAME}@${HWSERVER}:${REPORTS_DIRECTORY}/summary_html/ + +flags = -g +memory_debug : memory_flags = -m32 + +UNAME_S := $(shell uname -s) +ifeq ($(UNAME_S),Darwin) + flags = -g -std=c++11 +endif + +ifeq ($(UNAME_S),Linux) + flags = -g -std=c++0x +endif + +ifeq ($(findstring CYGWIN,$(UNAME_S)),CYGWIN) + flags = -g -std=c++11 +endif + +json_include = -I${nlohmann_json_dir}/include/ + + +remove_json_comments: customization.json + cpp -xc++ $< | sed -e '/^#/d' > customization_no_comments.json + python3 ${json_syntax_checker.py} customization_no_comments.json + grep '{"file":' customization_no_comments.json > iclicker_file_list.txt || true + python3 ${RAINBOW_GRADES_DIRECTORY}/parsexml.py iclicker_file_list.txt + +process_grades.out: \ + ${RAINBOW_GRADES_DIRECTORY}/main.cpp \ + ${RAINBOW_GRADES_DIRECTORY}/output.cpp \ + ${RAINBOW_GRADES_DIRECTORY}/table.cpp \ + ${RAINBOW_GRADES_DIRECTORY}/student.cpp \ + ${RAINBOW_GRADES_DIRECTORY}/iclicker.cpp \ + ${RAINBOW_GRADES_DIRECTORY}/zone.cpp \ + ${RAINBOW_GRADES_DIRECTORY}/benchmark.cpp + g++ -Wall ${flags} ${memory_flags} ${json_include} $^ -g -o $@ + +individual_summary_html all_students_summary_html: + mkdir -p $@ + +compile: remove_json_comments process_grades.out individual_summary_html all_students_summary_html + +clean: + rm -f process_grades.out + +src_clean: clean + rm -f ${json_syntax_checker.py} + rm -rf ${nlohmann_json_dir} + +all: pull overall push + +# ============================================================================= +# the different sorting orders & details of tables + +overall: ${nlohmann_json_dir} ${json_syntax_checker.py} compile + ./process_grades.out by_overall + +memory_debug: compile + drmemory -- ./process_grades.out by_overall + # valgrind ./process_grades.out by_overall + +iclicker: compile + ./process_grades.out by_iclicker + +name: compile + ./process_grades.out by_name + +section: compile + ./process_grades.out by_section + +lab: compile + ./process_grades.out by_lab + +hw: compile + ./process_grades.out by_hw + +test: compile + ./process_grades.out by_test + +quiz: compile + ./process_grades.out by_quiz + +exam: compile + ./process_grades.out by_exam + +reading: compile + ./process_grades.out by_reading + +project: compile + ./process_grades.out by_project + +participation: compile + ./process_grades.out by_participation + +test_exam: compile + ./process_grades.out by_test_and_exam + +zone: compile + ./process_grades.out by_zone + + +# ============================================================================= diff --git a/SAMPLE_Makefile b/SAMPLE_Makefile new file mode 100644 index 0000000..414a79f --- /dev/null +++ b/SAMPLE_Makefile @@ -0,0 +1,11 @@ +# ============================================================================= +# EDIT THESE VARIABLES + +USERNAME=username +RAINBOW_GRADES_DIRECTORY=//RainbowGrades +HWSERVER=submitty.cs.rpi.edu +REPORTS_DIRECTORY=/var/local/submitty/courses///reports + +# ============================================================================= + +include ${RAINBOW_GRADES_DIRECTORY}/MakefileHelper diff --git a/SAMPLE_customization.json b/SAMPLE_customization.json new file mode 100644 index 0000000..c07d6d8 --- /dev/null +++ b/SAMPLE_customization.json @@ -0,0 +1,150 @@ +/* +This JSON is based on the automatically generated customization for +the development course "sample" as of August 15, 2017. +It is intended as a simple example, with additional documentation online. +Going forward we expect more users to use a web interface to generate this file. +*/ +{ + "display_benchmark": [ + "average", + "stddev", + "perfect", + "lowest_a-", + "lowest_b-", + "lowest_c-", + "lowest_d" + ], + "section": { + "1": "ta2, ta3", + "2": "manne", + "3": "manne, ta3", + "4": "manne", + "5": "manne", + "6": "manne", + "7": "manne", + "8": "manne", + "9": "TBA", + "10": "TBA" + }, + "messages": [ + "sample Course", + "Note: Please be patient with data entry/grade corrections for the most recent lab, homework, and test.", + "Please contact your graduate lab TA if a grade remains missing or incorrect for more than a week." + ], + "display": [ + "instructor_notes", + "grade_summary", + "grade_details" + ], + "benchmark_percent": { + "lowest_c-": 0.7, + "lowest_d": 0.6, + "lowest_b-": 0.8, + "lowest_a-": 0.9 + }, + "gradeables": [ + { + "count": 4, + "percent": 0.75, + "type": "test", + "ids": [ + { + "max": 5.0, + "id": "future_no_tas_test", + "released": false + }, + { + "max": 5.0, + "id": "future_tas_test", + "released": false + }, + { + "max": 5.0, + "id": "grading_test", + "released": false + }, + { + "max": 5.0, + "id": "grades_released_test" + } + ] + }, + { + "count": 4, + "percent": 0.11, + "type": "lab", + "ids": [ + { + "max": 2.0, + "id": "future_no_tas_lab", + "released": false + }, + { + "max": 2.0, + "id": "future_tas_lab", + "released": false + }, + { + "max": 2.0, + "id": "grading_lab", + "released": false + }, + { + "max": 2.0, + "id": "grades_released_lab" + } + ] + }, + { + "count": 12, + "percent": 0.14, + "type": "homework", + "ids": [ + { + "max": 12.0, + "id": "open_homework", + "released": false + }, + { + "max": 12.0, + "id": "open_team_homework", + "released": false + }, + { + "max": 12.0, + "id": "closed_homework", + "released": false + }, + { + "max": 12.0, + "id": "grading_homework", + "released": false + }, + { + "max": 5.0, + "id": "grades_released_homework_onlyta" + }, + { + "max": 10, + "id": "grades_released_homework_onlyauto" + }, + { + "max": 22.0, + "id": "grades_released_homework_autota" + }, + { + "max": 26.0, + "id": "grades_released_homework_autohiddenEC" + }, + { + "max": 12.0, + "id": "grades_released_homework_onlytaEC" + }, + { + "max": 12.0, + "id": "grades_released_homework_onlytaPenalty" + } + ] + } + ] +} diff --git a/benchmark.cpp b/benchmark.cpp new file mode 100644 index 0000000..2ca3dcb --- /dev/null +++ b/benchmark.cpp @@ -0,0 +1,119 @@ +#include +#include + +#include "benchmark.h" + +std::vector > DISPLAY_BENCHMARKS; +int Benchmark::next_benchmark_position = 0; + +int FIND_BENCHMARK(const std::string& s) { + for (std::size_t i = 0; i < DISPLAY_BENCHMARKS.size(); i++) { + if (DISPLAY_BENCHMARKS[i].first == s) return i; + } + return -1; +} + +Benchmark::Benchmark(const std::string& s) { + assert (FIND_BENCHMARK(s) == -1); + assert (s == "extracredit" || + s == "perfect" || + s == "average" || + s == "stddev" || + s == "lowest_a-" || + s == "lowest_b-" || + s == "lowest_c-" || + s == "lowest_d" || + s == "failing"); + name = s; + visible = false; + percentage = -1; + color = "ffffff"; + position = -1; + DISPLAY_BENCHMARKS.push_back(std::make_pair(s,*this)); +} + +Benchmark& Benchmark::GetBenchmark(const std::string& s) { + assert (s == "extracredit" || + s == "perfect" || + s == "average" || + s == "stddev" || + s == "lowest_a-" || + s == "lowest_b-" || + s == "lowest_c-" || + s == "lowest_d" || + s == "failing"); + int i = FIND_BENCHMARK(s); + if (i == -1) { + Benchmark b(s); + i = FIND_BENCHMARK(s); + } + assert (i != -1); + return DISPLAY_BENCHMARKS[i].second; +} + + +void DisplayBenchmark(const std::string& s) { + Benchmark& b = Benchmark::GetBenchmark(s); + b.visible=true; + b.position = Benchmark::next_benchmark_position; + Benchmark::next_benchmark_position++; +} + +int NumVisibleBenchmarks() { + return Benchmark::next_benchmark_position; +} + +int WhichVisibleBenchmark(const std::string& s) { + for (std::size_t i = 0; i < DISPLAY_BENCHMARKS.size(); i++) { + if (DISPLAY_BENCHMARKS[i].first == s) { return DISPLAY_BENCHMARKS[i].second.position; } + } + return -1; +} + +void SetBenchmarkPercentage(const std::string& s, float v) { + assert (s == "lowest_a-" || + s == "lowest_b-" || + s == "lowest_c-" || + s == "lowest_d"); + Benchmark& b = Benchmark::GetBenchmark(s); + assert (v >= 0.0 && v <= 1.0); + b.percentage = v; +} + + +float GetBenchmarkPercentage(const std::string& s) { + assert (s == "lowest_a-" || + s == "lowest_b-" || + s == "lowest_c-" || + s == "lowest_d"); + Benchmark& b = Benchmark::GetBenchmark(s); + return b.percentage; +} + + + +void SetBenchmarkColor(const std::string& s, const std::string& c) { + assert (s == "extracredit" || + s == "perfect" || + s == "lowest_a-" || + s == "lowest_b-" || + s == "lowest_c-" || + s == "lowest_d" || + s == "failing"); + Benchmark& b = Benchmark::GetBenchmark(s); + assert (c.size() == 6); + b.color = c; +} + + +const std::string& GetBenchmarkColor(const std::string& s) { + assert (s == "extracredit" || + s == "perfect" || + s == "lowest_a-" || + s == "lowest_b-" || + s == "lowest_c-" || + s == "lowest_d" || + s == "failing"); + Benchmark& b = Benchmark::GetBenchmark(s); + return b.color; +} diff --git a/benchmark.h b/benchmark.h new file mode 100644 index 0000000..ad239d8 --- /dev/null +++ b/benchmark.h @@ -0,0 +1,41 @@ +#include +#include + +class Benchmark { +public: + Benchmark(const std::string& s); + + friend int NumVisibleBenchmarks(); + friend int WhichVisibleBenchmark(const std::string& s); + friend void DisplayBenchmark(const std::string& s); + friend void SetBenchmarkPercentage(const std::string& s, float v); + friend float GetBenchmarkPercentage(const std::string& s); + + friend void SetBenchmarkColor(const std::string& s, const std::string& c); + friend const std::string& GetBenchmarkColor(const std::string& s); + +private: + + static Benchmark& GetBenchmark(const std::string& s); + + int position; + std::string name; + bool visible; + float percentage; + std::string color; + static int next_benchmark_position; +}; + + +int NumVisibleBenchmarks(); +int WhichVisibleBenchmark(const std::string& s); +void DisplayBenchmark(const std::string& s); +void SetBenchmarkPercentage(const std::string& s, float v); +float GetBenchmarkPercentage(const std::string& s); + +void SetBenchmarkColor(const std::string& s, const std::string& c); +const std::string& GetBenchmarkColor(const std::string& s); + + +extern std::vector > DISPLAY_BENCHMARKS; + diff --git a/constants_and_globals.h b/constants_and_globals.h new file mode 100644 index 0000000..e303ce3 --- /dev/null +++ b/constants_and_globals.h @@ -0,0 +1,68 @@ +#ifndef __CONSTANTS_H__ +#define __CONSTANTS_H__ + +#define MAX_STRING_LENGTH 10000 + +#include +#include "grade.h" +class Student; + +// ========================================================== +// What sections to display in the output table +extern bool DISPLAY_INSTRUCTOR_NOTES; +extern bool DISPLAY_EXAM_SEATING; +extern bool DISPLAY_MOSS_DETAILS; +extern bool DISPLAY_FINAL_GRADE; +extern bool DISPLAY_GRADE_SUMMARY; +extern bool DISPLAY_GRADE_DETAILS; +extern bool DISPLAY_ICLICKER; +extern bool DISPLAY_LATE_DAYS; + +// ========================================================== +// messages for zone assignment +extern std::string GLOBAL_EXAM_TITLE; +extern std::string GLOBAL_EXAM_DATE; +extern std::string GLOBAL_EXAM_TIME; +extern std::string GLOBAL_EXAM_DEFAULT_ROOM; + +extern float GLOBAL_MIN_OVERALL_FOR_ZONE_ASSIGNMENT; + +extern std::vector MESSAGES; + + +// ========================================================== +extern Student* PERFECT_STUDENT_POINTER; + +extern bool TEST_IMPROVEMENT_AVERAGING_ADJUSTMENT; +extern float LATE_DAY_PERCENTAGE_PENALTY; +extern bool LOWEST_TEST_COUNTS_HALF; + +extern int QUIZ_NORMALIZE_AND_DROP; + +// ========================================================== +extern std::map sectionNames; +extern std::map sectionColors; + + +extern std::map CUTOFFS; +extern std::map grade_counts; +extern std::map grade_avg; +extern int took_final; +extern int dropped; +extern int auditors; +extern float LATE_DAY_PERCENTAGE_PENALTY; + +// ========================================================== +#define ICLICKER_RECENT 12 +#define ICLICKER_PRIORITY 0.666 +extern float MAX_ICLICKER_TOTAL; + + + +// ========================================================== +// PROTOTYPES + +bool validSection(int section); + + +#endif // __CONSTANTS_H__ diff --git a/curve.h b/curve.h new file mode 100644 index 0000000..4d3526e --- /dev/null +++ b/curve.h @@ -0,0 +1,81 @@ +#include +#include +#include +#include + + +class Curve { + +public: + + // ========================= + // CONSTRUCTOR + Curve() { + add("PERFECT",-1,-1); + add("AVERAGE",-1,-1); + } + + static Curve* DataStructuresCurve() { + Curve *curve = new Curve(); + curve->add("LOWEST A-", 0.30, -1); + curve->add("LOWEST B-", 0.30, -1); + curve->add("LOWEST C-", 0.30, -1); + curve->add("LOWEST D", -1, 0.5); + return curve; + } + + + static Curve* TypicalCurve() { + Curve *curve = new Curve(); + curve->add("LOWEST A-", -1, 0.9); + curve->add("LOWEST B-", -1, 0.8); + curve->add("LOWEST C-", -1, 0.7); + curve->add("LOWEST D", -1, 0.6); + return curve; + } + + // ========================= + // ACCESSORS + + int num() const { + assert (names.size() == target_distributions.size() && names.size() == fixed_percentages.size()); + return names.size(); + } + + const std::string& getName(int i) const { + assert (i >= 0 && i < num()); + return names[i]; + } + float getTargetDistribution(int i) const { + assert (i >= 0 && i < num()); + return target_distributions[i]; + } + float getFixedPercentage(int i) const { + assert (i >= 0 && i < num()); + return fixed_percentages[i]; + } + + // ========================= + // MODIFIER + void add(const std::string &name, float distribution, float percentage) { + names.push_back(name); + target_distributions.push_back(distribution); + fixed_percentages.push_back(percentage); + } + + +private: + + // ========================= + // REPRESENTATION + + // e.g. "perfect", "average", "lowest a-", etc. + std::vector names; + + // e.g., 30% A/A-, 30% B+/B/B-, 30% C+/C/C-, 10% D/F + std::vector target_distributions; + + // e.g., 90% / 80% / 70% / 60% + std::vector fixed_percentages; + +}; diff --git a/grade.h b/grade.h new file mode 100644 index 0000000..4763fee --- /dev/null +++ b/grade.h @@ -0,0 +1,15 @@ +#ifndef _GRADE_H_ +#define _GRADE_H_ + +#include + +class Grade { +public: + Grade(const std::string &v) : value(v) {} + std::string value; +}; + + +bool operator< (const Grade &a, const Grade &b); + +#endif diff --git a/gradeable.h b/gradeable.h new file mode 100644 index 0000000..e21ab50 --- /dev/null +++ b/gradeable.h @@ -0,0 +1,227 @@ +#ifndef _GRADEABLE_H_ +#define _GRADEABLE_H_ + +#include +#include +#include + + +enum class GRADEABLE_ENUM { + HOMEWORK, ASSIGNMENT, PROBLEM_SET, + QUIZ, TEST, EXAM, + EXERCISE, LECTURE_EXERCISE, READING, LAB, RECITATION, + PROJECT, PARTICIPATION, NOTE, + NONE }; + + +inline std::string gradeable_to_string(const GRADEABLE_ENUM &g) { + if (g == GRADEABLE_ENUM::HOMEWORK) { return "HOMEWORK"; } + if (g == GRADEABLE_ENUM::ASSIGNMENT) { return "ASSIGNMENT"; } + if (g == GRADEABLE_ENUM::PROBLEM_SET) { return "PROBLEM_SET"; } + if (g == GRADEABLE_ENUM::QUIZ) { return "QUIZ"; } + if (g == GRADEABLE_ENUM::TEST) { return "TEST"; } + if (g == GRADEABLE_ENUM::EXAM) { return "EXAM"; } + if (g == GRADEABLE_ENUM::EXERCISE) { return "EXERCISE"; } + if (g == GRADEABLE_ENUM::LECTURE_EXERCISE) { return "LECTURE_EXERCISE"; } + if (g == GRADEABLE_ENUM::READING) { return "READING"; } + if (g == GRADEABLE_ENUM::LAB) { return "LAB"; } + if (g == GRADEABLE_ENUM::RECITATION) { return "RECITATION"; } + if (g == GRADEABLE_ENUM::PROJECT) { return "PROJECT"; } + if (g == GRADEABLE_ENUM::PARTICIPATION) { return "PARTICIPATION"; } + if (g == GRADEABLE_ENUM::NOTE) { return "NOTE"; } + if (g == GRADEABLE_ENUM::NONE) { return "NONE"; } + std::cerr << "ERROR! UNKNOWN GRADEABLE" << std::endl; + exit(0); +} + +inline std::string spacify(const std::string &s) { + std::string tmp = ""; + for (int i = 0; i < s.size(); i++) { + tmp += std::string(1,s[i]) + " "; + } + return tmp; +} + + +// =============================================================================== + +class Gradeable { + +public: + + // CONSTRUTORS + Gradeable() { count=0;percent=0;remove_lowest=0; } + Gradeable(int c, float p) : count(c),percent(p) { remove_lowest=0; } + + // ACCESSORS + int getCount() const { return count; } + float getPercent() const { return percent; } + float getMaximum() const { + if (maximums.size() == 0) return 0; + assert (maximums.size() > 0); + int max_sum = 0; + for (std::map::const_iterator itr = maximums.begin(); + itr != maximums.end(); itr++) { + max_sum += itr->second; + } + return max_sum * getCount() / maximums.size(); + } + int getRemoveLowest() const { return remove_lowest; } + + std::string getID(int index) const { + std::map >::const_iterator itr = correspondences.begin(); + while (itr != correspondences.end()) { + if (itr->second.first == index) return itr->first; + itr++; + } + return ""; + } + + void isResubmit(int index, + std::string &original_id, std::string &resubmit_id, + float &autograde_replacement_percentage) { + std::string id = getID(index); + if (original_ids.find(id) == original_ids.end()) return; + assert (resubmit_ids.find(id) != resubmit_ids.end()); + assert (autograde_replacement_percentages.find(id) != autograde_replacement_percentages.end()); + original_id = original_ids.find(id)->second; + resubmit_id = resubmit_ids.find(id)->second; + autograde_replacement_percentage = autograde_replacement_percentages.find(id)->second; + } + + bool hasCorrespondence(const std::string &id) const { + /* + for (std::map >::const_iterator itr = correspondences.begin(); + itr != correspondences.end(); itr++) { + std::cout << "looking for " << id << " " << itr->first << std::endl; + } + */ + std::map >::const_iterator itr = correspondences.find(id); + return (itr != correspondences.end()); + } + + const std::pair& getCorrespondence(const std::string& id) { + assert (hasCorrespondence(id)); + return correspondences.find(id)->second; + } + + bool isReleased(const std::string &id) const { + assert (released.find(id) != released.end()); + return released.find(id)->second; + } + float getItemMaximum(const std::string &id) const { + assert (maximums.find(id) != maximums.end()); + return maximums.find(id)->second; + } + float getScaleMaximum(const std::string &id) const { + if (scale_maximums.find(id) == scale_maximums.end()) { + return -1; + } + return scale_maximums.find(id)->second; + } + float getItemPercentage(const std::string &id) const { + if (item_percentages.find(id) == item_percentages.end()) + return -1; + else + return item_percentages.find(id)->second; + } + float getClamp(const std::string &id) const { + assert (clamps.find(id) != clamps.end()); + return clamps.find(id)->second; + } + + // MODIFIERS + void setRemoveLowest(int r) { remove_lowest=r; } + + int setCorrespondence(const std::string& id) { + assert (!hasCorrespondence(id)); + //std::cout << "SET CORR " << id << std::endl; + assert (int(correspondences.size()) < count); + int index = correspondences.size(); + correspondences[id] = std::make_pair(index,""); + return index; + } + + void setCorrespondenceName(const std::string& id, const std::string& name) { + assert (hasCorrespondence(id)); + assert (correspondences[id].second == ""); + correspondences[id].second = name; + } + + void setReleased(const std::string&id, bool is_released) { + assert (hasCorrespondence(id)); + assert (released.find(id) == released.end()); + released[id] = is_released; + } + + void setMaximum(const std::string&id, float maximum) { + assert (hasCorrespondence(id)); + assert (maximums.find(id) == maximums.end()); + maximums[id] = maximum; + } + void setScaleMaximum(const std::string&id, float scale_maximum) { + assert (hasCorrespondence(id)); + assert (scale_maximums.find(id) == scale_maximums.end()); + scale_maximums[id] = scale_maximum; + } + void setItemPercentage(const std::string&id, float item_percentage) { + assert (hasCorrespondence(id)); + assert (item_percentages.find(id) == item_percentages.end()); + item_percentages[id] = item_percentage; + } + void setClamp(const std::string&id, float clamp) { + assert (hasCorrespondence(id)); + assert (clamps.find(id) == clamps.end()); + clamps[id] = clamp; + } + + void setResubmissionValues(const std::string &id, + const std::string &original_id, const std::string &resubmit_id, + const std::string &title, + float autograde_replacement_percentage) { + setCorrespondenceName(id,title); + original_ids[id] = original_id; + resubmit_ids[id] = resubmit_id; + autograde_replacement_percentages[id] = autograde_replacement_percentage; + } + +private: + + // REPRESENTATION + int count; + float percent; + int remove_lowest; + std::map > correspondences; + std::map maximums; + std::map scale_maximums; + std::map item_percentages; + std::map clamps; + std::map released; + std::map original_ids; + std::map resubmit_ids; + std::map autograde_replacement_percentages; +}; + +// =============================================================================== + +extern std::vector ALL_GRADEABLES; + +extern std::map GRADEABLES; + + +inline void LookupGradeable(const std::string &id, + GRADEABLE_ENUM &g_e, int &i) { + for (std::size_t k = 0; k < ALL_GRADEABLES.size(); k++) { + GRADEABLE_ENUM e = ALL_GRADEABLES[k]; + Gradeable g = GRADEABLES[e]; + if (g.hasCorrespondence(id)) { + g_e = e; + i = g.getCorrespondence(id).first; + return; + } + } + assert (0); +} + + +#endif diff --git a/iclicker.cpp b/iclicker.cpp new file mode 100644 index 0000000..e4e7420 --- /dev/null +++ b/iclicker.cpp @@ -0,0 +1,240 @@ +#include +#include +#include +#include + +#include "iclicker.h" +#include "student.h" + +extern std::vector ICLICKER_QUESTION_NAMES; +extern float MAX_ICLICKER_TOTAL; + +std::vector GLOBAL_earned_late_days; + +std::map LECTURE_DATE_CORRESPONDENCES; + +Student* GetStudent(const std::vector &students, const std::string& name); + +//Internally change .xml paths to .csv paths +void iClickerQuestion::handleXMLFilename(const std::string& f){ + filename = f; + if(filename.substr(filename.size()-4) == ".xml"){ + filename.resize(filename.size()-3); + filename += "csv"; + } +} + +Date dateFromFilename(const std::string& filename_with_directory) { + + std::string filename = filename_with_directory; + while (true) { + std::string::size_type pos = filename.find('/'); + if (pos == std::string::npos) break; + filename = filename.substr(pos+1,filename.size()-pos-1); + } + + assert (filename.size() == 15); + assert (filename[0] == 'L'); + // assert (filename[7] == '_'); + assert (filename.substr(11,4) == ".csv"); + + Date answer; + + answer.year = 2000 + atoi(filename.substr(1,2).c_str()); + answer.month = atoi(filename.substr(3,2).c_str()); + answer.day = atoi(filename.substr(5,2).c_str()); + + //std::cout << "YEAR " << answer.year << std::endl; + //std::cout << "MONTH " << answer.month << std::endl; + //std::cout << "DAY " << answer.day << std::endl; + + assert (answer.month >= 1 && answer.month <= 12); + assert (answer.day >= 1 && answer.day <= 31); + + return answer; +} + + +std::string ReadRemote(std::istream &istr) { + char c; + std::string answer; + if (!istr.good()) return ""; + istr >> c; + if (!istr.good()) return ""; + if (c != '#') return answer; + answer = "#"; + while (1) { + istr >> c; + if (c == ',') break; + answer.push_back(c); + } + if (answer == "#T24RLR15") { + std::cerr << "ERROR! " << answer << " is not a valid remote ID, this is the clicker model #" << std::endl; + return ""; + } + return answer; +} + +std::string ReadQuoted(std::istream &istr) { + char c; + std::string answer; + //bool success = true; + if ( !(istr >> c) || c != '"') { + //std::cout << success << " OOPS not quote '" << c << "'" << std::endl; + } + + while (istr >> c) { + if (c == '"') break; + answer.push_back(c); + } + //std::cout << "FOUND " << answer < GLOBAL_CLICKER_MAP; + + +void MatchClickerRemotes(std::vector &students, const std::string &remotes_filename) { + if (remotes_filename == "") return; + std::cout << "READING CLICKER REMOTES FILE: " << remotes_filename << std::endl; + + std::ifstream istr(remotes_filename.c_str()); + if (!istr) return; + + while (1) { + std::string remote = ReadRemote(istr); + std::string username = ReadQuoted(istr); + if (username == "") break; + if (remote == "") { + std::cerr << "ERROR! blank remoteid for " << username << std::endl; + continue; + } + //std::cout << "tokens: " << remote << " " << username << std::endl; + Student *s = GetStudent(students,username); + if (s == NULL) { + std::cout << "BAD USERNAME FOR CLICKER MATCHING " << username << std::endl; + exit(0); + continue; + } + assert (s != NULL); + if (s->getRemoteID().size() != 0) { + std::cout << "student " << username << " has multiple remotes (replacing a lost remote)" << std::endl; + } + s->setRemoteID(remote); + //std::cout << "MATCH " << username << " " << remote << std::endl; + if (GLOBAL_CLICKER_MAP.find(remote) != GLOBAL_CLICKER_MAP.end()) { + std::cout << "ERROR! already have this clicker assigned " << remote << " " << s->getUserName() << std::endl; + } + assert (GLOBAL_CLICKER_MAP.find(remote) == GLOBAL_CLICKER_MAP.end()); + GLOBAL_CLICKER_MAP[remote] = username; + } +} + + +std::string getItem(const std::string &line, int which) { + std::string::size_type comma_before = 0; + for (int i = 0; i < which; i++) { + comma_before = line.find(',',comma_before)+1; + assert (comma_before != std::string::npos); + } + int comma_after = line.find(',',comma_before); + return line.substr(comma_before,comma_after-comma_before); +} + + +void AddClickerScores(std::vector &students, std::vector > > iclicker_questions) { + + for (unsigned int which_lecture = 0; which_lecture < iclicker_questions.size(); which_lecture++) { + //std::cout << "which lecture = " << which_lecture << std::endl; + std::vector >& lecture = iclicker_questions[which_lecture]; + //for (unsigned int which_question = 0; which_question < lecture.size(); which_question++) { + for (std::size_t which_question = 0; which_question < lecture.size(); which_question++){ + //unsigned int which_question = it->first; + //iClickerQuestion& question = lecture[which_question]; + + std::stringstream ss; + ss << which_lecture << "." << which_question+1; + + for(unsigned int i=0; i::iterator itr = GLOBAL_CLICKER_MAP.find(remoteid); + if (itr == GLOBAL_CLICKER_MAP.end()) { + //std::cout << "UNKNOWN CLICKER: " << remoteid << " " << std::endl; + std::cout << " " << remoteid; + continue; + } + assert(itr != GLOBAL_CLICKER_MAP.end()); + std::string username = itr->second; + Student *s = GetStudent(students, username); + assert(s != NULL); + + iclicker_answer_enum grade = ICLICKER_NOANSWER; + if (question.participationQuestion()) + grade = ICLICKER_PARTICIPATED; + else { + if (question.isCorrectAnswer(item[0])) { + grade = ICLICKER_CORRECT; + } else { + grade = ICLICKER_INCORRECT; + } + } + + s->addIClickerAnswer(ss.str(), item[0], grade); + //s.seti + + } + std::cout << std::endl; + } + } + } +} diff --git a/iclicker.h b/iclicker.h new file mode 100644 index 0000000..f061367 --- /dev/null +++ b/iclicker.h @@ -0,0 +1,69 @@ +#ifndef _ICLICKER_H_ +#define _ICLICKER_H_ + +#include +#include +#include +#include +#include + + +#define MAX_LECTURES 28 + +extern std::vector GLOBAL_earned_late_days; + +class Student; + +class Date { +public: + int year; + int month; + int day; + + std::string getStringRep() { + std::stringstream ss; + ss << std::setw(2) << std::setfill('0') << month + << "/" + << std::setw(2) << std::setfill('0') << day + << "/" + << std::setw(4) << year; + return ss.str(); + } +}; + + +enum iclicker_answer_enum { ICLICKER_NOANSWER, ICLICKER_INCORRECT, ICLICKER_PARTICIPATED, ICLICKER_CORRECT }; + +extern std::vector ICLICKER_QUESTION_NAMES; + +extern std::map LECTURE_DATE_CORRESPONDENCES; + +// ========================================================== + +class iClickerQuestion { +public: + iClickerQuestion(const std::string& f, int q, const std::string& ca) { + handleXMLFilename(f); + which_question = q; + assert (which_question >= 0 && which_question < 20); + correct_answer = ca; + } + + const std::string& getFilename() const { return filename; } + int getColumn() const { return 4 + (which_question-1)*6; } + bool participationQuestion() const { return correct_answer == "ABCDE"; } + bool isCorrectAnswer(char c) { return correct_answer.find(c) != std::string::npos; } + void handleXMLFilename(const std::string& f); + +private: + std::string filename; + int which_question; + std::string correct_answer; +}; + +// ========================================================== + +void MatchClickerRemotes(std::vector &students, const std::string &remotes_filename); +void AddClickerScores(std::vector &students, std::vector > > iclicker_questions); + +#endif diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..bee53d5 --- /dev/null +++ b/main.cpp @@ -0,0 +1,1812 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "benchmark.h" + +std::string GLOBAL_sort_order; + + +int GLOBAL_ACTIVE_TEST_ZONE = 0; + +#include "student.h" +#include "iclicker.h" +#include "gradeable.h" +#include "grade.h" +#include + +// defined in iclicker.cpp +std::string ReadQuoted(std::istream &istr); +void suggest_curves(std::vector &students); + +std::string GLOBAL_recommend_id = ""; + + +//==================================================================== +// DIRECTORIES & FILES + +std::string ICLICKER_ROSTER_FILE = "./iclicker_Roster.txt"; +std::string OUTPUT_FILE = "./output.html"; +std::string CUSTOMIZATION_FILE = "./customization_no_comments.json"; + +std::string RAW_DATA_DIRECTORY = "./raw_data/"; +std::string INDIVIDUAL_FILES_OUTPUT_DIRECTORY = "./individual_summary_html/"; +std::string ALL_STUDENTS_OUTPUT_DIRECTORY = "./all_students_summary_html/"; + +nlohmann::json GLOBAL_CUSTOMIZATION_JSON; + + +//==================================================================== +// INFO ABOUT GRADING FOR COURSE + +std::vector ALL_GRADEABLES; + +std::map GRADEABLES; + +float LATE_DAY_PERCENTAGE_PENALTY = 0; +bool TEST_IMPROVEMENT_AVERAGING_ADJUSTMENT = false; +bool LOWEST_TEST_COUNTS_HALF = false; + +int QUIZ_NORMALIZE_AND_DROP = 0; + +std::vector ICLICKER_QUESTION_NAMES; +float MAX_ICLICKER_TOTAL; + +std::map CUTOFFS; + +std::map grade_counts; +std::map grade_avg; +int took_final = 0; +int auditors = 0; +int dropped = 0; + +Student* PERFECT_STUDENT_POINTER; +Student* AVERAGE_STUDENT_POINTER; +Student* STDDEV_STUDENT_POINTER; + +//==================================================================== +// INFO ABOUT NUMBER OF SECTIONS + +std::map sectionNames; +std::map sectionColors; + +bool validSection(int section) { + + nlohmann::json::iterator itr = GLOBAL_CUSTOMIZATION_JSON.find("section"); + assert (itr != GLOBAL_CUSTOMIZATION_JSON.end()); + assert (itr->is_object()); + + nlohmann::json::iterator itr2 = itr->find(std::to_string(section)); + if (itr2 == itr->end()) return false; + return true; + + //return (sectionNames.find(section) != sectionNames.end()); +} + + +std::string sectionName(int section) { + std::map::const_iterator itr = sectionNames.find(section); + if (itr == sectionNames.end()) + return "NONE"; + return itr->second; +} + + + + +//==================================================================== + +std::string GLOBAL_EXAM_TITLE = "exam title uninitialized"; +std::string GLOBAL_EXAM_DATE = "exam date uninitialized"; +std::string GLOBAL_EXAM_TIME = "exam time uninitialized"; +std::string GLOBAL_EXAM_DEFAULT_ROOM = "exam default room uninitialized"; +std::string GLOBAL_EXAM_SEATING = ""; +std::string GLOBAL_SEATING_SPACING = ""; +std::string GLOBAL_EXAM_SEATING_COUNT = ""; +std::string GLOBAL_LEFT_RIGHT_HANDEDNESS = ""; + +float GLOBAL_MIN_OVERALL_FOR_ZONE_ASSIGNMENT = 0.1; + +int BONUS_WHICH_LECTURE = -1; +std::string BONUS_FILE; + +//==================================================================== +// INFO ABOUT OUTPUT FORMATTING + +bool DISPLAY_INSTRUCTOR_NOTES = false; +bool DISPLAY_EXAM_SEATING = false; +bool DISPLAY_MOSS_DETAILS = false; +bool DISPLAY_FINAL_GRADE = false; +bool DISPLAY_GRADE_SUMMARY = false; +bool DISPLAY_GRADE_DETAILS = false; +bool DISPLAY_ICLICKER = false; +bool DISPLAY_LATE_DAYS = false; + + +std::vector MESSAGES; + + +//==================================================================== + +std::ofstream priority_stream("priority.txt"); +std::ofstream late_days_stream("late_days.txt"); + +void PrintExamRoomAndZoneTable(std::ofstream &ostr, Student *s, const nlohmann::json &special_message); + +//==================================================================== + + + + + +//==================================================================== +// sorting routines + + +bool by_overall(const Student* s1, const Student* s2) { + float s1_overall = s1->overall_b4_moss(); + float s2_overall = s2->overall_b4_moss(); + + if (s1 == AVERAGE_STUDENT_POINTER) return true; + if (s2 == AVERAGE_STUDENT_POINTER) return false; + if (s1 == STDDEV_STUDENT_POINTER) return true; + if (s2 == STDDEV_STUDENT_POINTER) return false; + + if (s1_overall > s2_overall+0.0001) return true; + if (fabs (s1_overall - s2_overall) < 0.0001 && + s1->getSection() == 0 && + s2->getSection() != 0) + return true; + + return false; +} + + +bool by_test_and_exam(const Student* s1, const Student* s2) { + float val1 = s1->GradeablePercent(GRADEABLE_ENUM::TEST) + s1->GradeablePercent(GRADEABLE_ENUM::EXAM); + float val2 = s2->GradeablePercent(GRADEABLE_ENUM::TEST) + s2->GradeablePercent(GRADEABLE_ENUM::EXAM); + + if (val1 > val2) return true; + if (fabs (val1-val2) < 0.0001 && + s1->getSection() == 0 && + s2->getSection() != 0) + return true; + + return false; +} + + + + +// FOR GRADEABLES +class GradeableSorter { +public: + GradeableSorter(GRADEABLE_ENUM g) : g_(g) {} + bool operator()(Student *s1, Student *s2) { + return (s1->GradeablePercent(g_) > s2->GradeablePercent(g_) || + (s1->GradeablePercent(g_) == s2->GradeablePercent(g_) && + by_overall(s1,s2))); + } +private: + GRADEABLE_ENUM g_; +}; + + +// FOR OTHER THINGS + + +bool by_name(const Student* s1, const Student* s2) { + return (s1->getLastName() < s2->getLastName() || + (s1->getLastName() == s2->getLastName() && + s1->getPreferredName() < s2->getPreferredName())); +} + + +bool by_section(const Student *s1, const Student *s2) { + if (s2->getIndependentStudy() == true && s1->getIndependentStudy() == false) return false; + if (s2->getIndependentStudy() == false && s1->getIndependentStudy() == true) return false; + if (s2->getSection() <= 0 && s1->getSection() <= 0) { + return by_name(s1,s2); + } + if (s2->getSection() == 0) return true; + if (s1->getSection() == 0) return false; + if (s1->getSection() < s2->getSection()) return true; + if (s1->getSection() > s2->getSection()) return false; + return by_name(s1,s2); +} + +bool by_iclicker(const Student* s1, const Student* s2) { + return (s1->getIClickerTotalFromStart() > s2->getIClickerTotalFromStart()); +} + + +// sorting function for letter grades +bool operator< (const Grade &a, const Grade &b) { + if (a.value == b.value) return false; + + if (a.value == "A") return true; + if (b.value == "A") return false; + if (a.value == "A-") return true; + if (b.value == "A-") return false; + + if (a.value == "B+") return true; + if (b.value == "B+") return false; + if (a.value == "B") return true; + if (b.value == "B") return false; + if (a.value == "B-") return true; + if (b.value == "B-") return false; + + if (a.value == "C+") return true; + if (b.value == "C+") return false; + if (a.value == "C") return true; + if (b.value == "C") return false; + if (a.value == "C-") return true; + if (b.value == "C-") return false; + + if (a.value == "D+") return true; + if (b.value == "D+") return false; + if (a.value == "D") return true; + if (b.value == "D") return false; + + if (a.value == "F") return true; + if (b.value == "F") return false; + + return false; +} + +//==================================================================== +/* +void gradeable_helper(std::ifstream& istr, GRADEABLE_ENUM g) { + int c; float p, m; + istr >> c >> p >> m; + assert (GRADEABLES.find(g) == GRADEABLES.end()); + + Gradeable answer (c,p,m); + GRADEABLES.insert(std::make_pair(g,answer)); + assert (GRADEABLES[g].getCount() >= 0); + assert (GRADEABLES[g].getPercent() >= 0.0 && GRADEABLES[g].getPercent() <= 1.0); + assert (GRADEABLES[g].getMaximum() >= 0.0); +} +*/ + +bool string_to_gradeable_enum(const std::string &s, GRADEABLE_ENUM &return_value) { + std::string s2; + for (unsigned int i = 0; i < s.size(); ++i) { + s2.push_back(std::tolower(s[i])); + } + std::replace( s2.begin(), s2.end(), '-', '_'); + if (s2 == "hw" || s2 == "homework") { return_value = GRADEABLE_ENUM::HOMEWORK; return true; } + if (s2 == "assignment") { return_value = GRADEABLE_ENUM::ASSIGNMENT; return true; } + if (s2 == "problem_set") { return_value = GRADEABLE_ENUM::PROBLEM_SET; return true; } + if (s2 == "quiz" || s2 == "quizze") { return_value = GRADEABLE_ENUM::QUIZ; return true; } + if (s2 == "test") { return_value = GRADEABLE_ENUM::TEST; return true; } + if (s2 == "exam") { return_value = GRADEABLE_ENUM::EXAM; return true; } + if (s2 == "exercise") { return_value = GRADEABLE_ENUM::EXERCISE; return true; } + if (s2 == "lecture_exercise") { return_value = GRADEABLE_ENUM::LECTURE_EXERCISE; return true; } + if (s2 == "reading") { return_value = GRADEABLE_ENUM::READING; return true; } + if (s2 == "lab") { return_value = GRADEABLE_ENUM::LAB; return true; } + if (s2 == "recitation") { return_value = GRADEABLE_ENUM::RECITATION; return true; } + if (s2 == "project") { return_value = GRADEABLE_ENUM::PROJECT; return true; } + if (s2 == "participation") { return_value = GRADEABLE_ENUM::PARTICIPATION; return true; } + if (s2 == "instructor_note" || s2 == "note") { return_value = GRADEABLE_ENUM::NOTE; return true; } + if (s2 == "note") { return_value = GRADEABLE_ENUM::NOTE; return true; } + if (s2.substr(0,4) == "none") { return_value = GRADEABLE_ENUM::NOTE; return true; } + return false; +} + +//==================================================================== + + +void preprocesscustomizationfile(std::vector &students) { + /* + std::ifstream istr(CUSTOMIZATION_FILE.c_str()); + assert (istr); + std::string token; + + while (istr >> token) { + if (token[0] == '#') { + // comment line! + char line[MAX_STRING_LENGTH]; + istr.getline(line,MAX_STRING_LENGTH); + + } else if (token.size() > 4 && token.substr(0,4) == "num_") { + + GRADEABLE_ENUM g; + // also take 's' off the end + bool success = string_to_gradeable_enum(token.substr(4,token.size()-5),g); + + if (success) { + gradeable_helper(istr,g); + + ALL_GRADEABLES.push_back(g); + + } else { + std::cout << "UNKNOWN GRADEABLE: " << token.substr(4,token.size()-5) << std::endl; + exit(0); + } + + } else if (token == "hackmaxprojects") { + + char line[MAX_STRING_LENGTH]; + istr.getline(line,MAX_STRING_LENGTH); + std::stringstream ss(line); + std::vector items; + std::string i; + while (ss >> i) { + items.push_back(i); + } + std::cout << "HACK MAX " << items.size() << std::endl; + + std::cout << " HMP=" << HACKMAXPROJECTS.size() << std::endl; + + HACKMAXPROJECTS.push_back(items); + + } else if (token == "display") { + istr >> token; + + if (token == "instructor_notes") { + DISPLAY_INSTRUCTOR_NOTES = true; + } else if (token == "exam_seating") { + DISPLAY_EXAM_SEATING = true; + } else if (token == "moss_details") { + DISPLAY_MOSS_DETAILS = true; + } else if (token == "final_grade") { + DISPLAY_FINAL_GRADE = true; + } else if (token == "grade_summary") { + DISPLAY_GRADE_SUMMARY = true; + } else if (token == "grade_details") { + DISPLAY_GRADE_DETAILS = true; + } else if (token == "iclicker") { + DISPLAY_ICLICKER = true; + + } else { + std::cout << "OOPS " << token << std::endl; + exit(0); + } + char line[MAX_STRING_LENGTH]; + istr.getline(line,MAX_STRING_LENGTH); + + } else if (token == "display_benchmark") { + istr >> token; + DisplayBenchmark(token); + + } else if (token == "benchmark_percent") { + istr >> token; + float value; + istr >> value; + + SetBenchmarkPercentage(token,value); + + } else if (token == "benchmark_color") { + istr >> token; + std::string color; + istr >> color; + + SetBenchmarkColor(token,color); + + } else if (token == "use") { + + istr >> token; + + if (token == "late_day_penalty") { + istr >> LATE_DAY_PERCENTAGE_PENALTY; + assert (LATE_DAY_PERCENTAGE_PENALTY >= 0.0 && LATE_DAY_PERCENTAGE_PENALTY < 0.25); + char line[MAX_STRING_LENGTH]; + istr.getline(line,MAX_STRING_LENGTH); + } else if (token == "test_improvement_averaging_adjustment") { + TEST_IMPROVEMENT_AVERAGING_ADJUSTMENT = true; + } else if (token == "quiz_normalize_and_drop_two") { + QUIZ_NORMALIZE_AND_DROP_TWO = true; + } else if (token == "lowest_test_counts_half") { + LOWEST_TEST_COUNTS_HALF = true; + } else { + std::cout << "ERROR: unknown use " << token << std::endl; + exit(0); + } + + } else if (token == "remove_lowest") { + istr >> token; + if (token == "HOMEWORK") { + int num; + istr >> num; + assert (num >= 0 && num < GRADEABLES[GRADEABLE_ENUM::HOMEWORK].getCount()); + GRADEABLES[GRADEABLE_ENUM::HOMEWORK].setRemoveLowest(num); + } + } + } + */ + // --------------------------------------------------------------------------------------- + + std::ifstream istr(CUSTOMIZATION_FILE.c_str()); + assert (istr.good()); + nlohmann::json j = nlohmann::json::parse(istr); + + std::string token; + float p_score,a_score,b_score,c_score,d_score; + + Student *perfect = GetStudent(students,"PERFECT"); + Student *student_average = GetStudent(students,"AVERAGE"); + Student *student_stddev = GetStudent(students,"STDDEV"); + Student *lowest_a = GetStudent(students,"LOWEST A-"); + Student *lowest_b = GetStudent(students,"LOWEST B-"); + Student *lowest_c = GetStudent(students,"LOWEST C-"); + Student *lowest_d = GetStudent(students,"LOWEST D"); + + //std::cout << "0" << std::endl; + + + // load gradeables + nlohmann::json all_gradeables = j["gradeables"]; + int num_gradeables = all_gradeables.size(); + + float sum_of_percents = 0; + + for (int i = 0; i < num_gradeables; i++) { + nlohmann::json one_gradeable_type = all_gradeables[i]; + GRADEABLE_ENUM g; + + // TYPE + nlohmann::json::iterator itr = one_gradeable_type.find("type"); + assert (itr != one_gradeable_type.end()); + std::string gradeable_type = itr->get(); + bool success = string_to_gradeable_enum(gradeable_type, g); + if (!success) { + std::cout << "UNKNOWN GRADEABLE TYPE: " << gradeable_type << std::endl; + exit(0); + } + + // PERCENT + itr = one_gradeable_type.find("percent"); + assert (itr != one_gradeable_type.end()); + float gradeable_total_percent = itr->get(); + assert (gradeable_total_percent >= 0); + sum_of_percents += gradeable_total_percent; + + int count = one_gradeable_type.value("count",-1); + + nlohmann::json ids_list = one_gradeable_type["ids"]; + for (unsigned int k = 0; k < ids_list.size(); k++) { + nlohmann::json ids = ids_list[k]; + std::string gradeable_id = ids.value("id",""); + assert (gradeable_id != ""); + } + if (count == -1) { + count = ids_list.size(); + } + //If we ever have more than INT_MAX ids, this will wrap. + //Needed to resolve int vs uint comparison and this is preferable since + //presumably the json library is spitting out an int and the customization.json + //also assumes int. + assert (int(ids_list.size()) <= count); + + Gradeable answer (count,gradeable_total_percent); //,m); + GRADEABLES.insert(std::make_pair(g,answer)); + assert (GRADEABLES[g].getCount() >= 0); + assert (GRADEABLES[g].getPercent() >= 0.0 && GRADEABLES[g].getPercent() <= 1.0); + + // Set remove lowest for gradeable + int num = one_gradeable_type.value("remove_lowest", 0); + assert (num == 0 || (num >= 0 && num < GRADEABLES[g].getCount())); + GRADEABLES[g].setRemoveLowest(num); + ALL_GRADEABLES.push_back(g); + } + + // Set Benchmark Percent + + std::vector benchmark_percents; + + nlohmann::json benchmarkPercent = j["benchmark_percent"]; + for (nlohmann::json::iterator itr = benchmarkPercent.begin(); itr != benchmarkPercent.end(); itr++) { + token = itr.key(); + float value; + value = itr.value(); + SetBenchmarkPercentage(token,value); + benchmark_percents.push_back(token); + } + + + + perfect = new Student();perfect->setUserName("PERFECT"); + student_average = new Student();student_average->setUserName("AVERAGE"); + student_stddev = new Student();student_stddev->setUserName("STDDEV"); + + lowest_a = new Student();lowest_a->setUserName("LOWEST A-");lowest_a->setLegalFirstName("approximate"); + lowest_b = new Student();lowest_b->setUserName("LOWEST B-");lowest_b->setLegalFirstName("approximate"); + lowest_c = new Student();lowest_c->setUserName("LOWEST C-");lowest_c->setLegalFirstName("approximate"); + lowest_d = new Student();lowest_d->setUserName("LOWEST D"); lowest_d->setLegalFirstName("approximate"); + + PERFECT_STUDENT_POINTER = perfect; + AVERAGE_STUDENT_POINTER = student_average; + STDDEV_STUDENT_POINTER = student_stddev; + + for (int i = 0; i < num_gradeables; i++) { + + nlohmann::json one_gradeable_type = all_gradeables[i]; + + GRADEABLE_ENUM g; + nlohmann::json::iterator itr = one_gradeable_type.find("type"); + assert (itr != one_gradeable_type.end()); + std::string gradeable_type = itr->get(); + bool success = string_to_gradeable_enum(gradeable_type, g); + if (!success) { + std::cout << "UNKNOWN GRADEABLE: " << gradeable_type << std::endl; + exit(0); + } + nlohmann::json ids_list = one_gradeable_type["ids"]; + + for (unsigned int k = 0; k < ids_list.size(); k++) { + nlohmann::json grade_id = ids_list[k]; + std::string token_key = grade_id.value("id",""); + assert (token_key != ""); + + int which = GRADEABLES[g].setCorrespondence(token_key); + p_score = grade_id.value("max", 0.0); + + std::vector curve = grade_id.value("curve",std::vector()); + + a_score = GetBenchmarkPercentage("lowest_a-")*p_score; + b_score = GetBenchmarkPercentage("lowest_b-")*p_score; + c_score = GetBenchmarkPercentage("lowest_c-")*p_score; + d_score = GetBenchmarkPercentage("lowest_d")*p_score; + + if (!curve.empty()) { + assert(curve.size() == benchmark_percents.size()); + for (std::size_t x = 0; x < benchmark_percents.size(); x++) { + if (benchmark_percents[x] == "lowest_a-") a_score = curve[x]; + if (benchmark_percents[x] == "lowest_b-") b_score = curve[x]; + if (benchmark_percents[x] == "lowest_c-") c_score = curve[x]; + if (benchmark_percents[x] == "lowest_d") d_score = curve[x]; + } + } + + c_score = std::min(b_score,c_score); + d_score = std::min(c_score,d_score); + + bool released = grade_id.value("released",true); + GRADEABLES[g].setReleased(token_key,released); + + float maximum = grade_id.value("max",0); + GRADEABLES[g].setMaximum(token_key,maximum); + + if (grade_id.find("scale_max") != grade_id.end()) { + float scale_maximum = grade_id.value("scale_max",0); + assert (scale_maximum > 0); + GRADEABLES[g].setScaleMaximum(token_key,scale_maximum); + } + if (grade_id.find("percent") != grade_id.end()) { + float item_percentage = grade_id.value("percent",-1.0); + assert (item_percentage >= 0 && item_percentage <= 1.0); + GRADEABLES[g].setItemPercentage(token_key,item_percentage); + } + float clamp = grade_id.value("clamp",-1); + GRADEABLES[g].setClamp(token_key,clamp); + + if (grade_id.find("autograde_replacement_percentage") != grade_id.end()) { + assert (grade_id.find("original_id") != grade_id.end()); + assert (grade_id.find("resubmit_id") != grade_id.end()); + assert (grade_id.find("title") != grade_id.end()); + + std::string o_id = grade_id.value("original_id",""); + std::string r_id = grade_id.value("resubmit_id",""); + std::string t = grade_id.value("title",""); + float a_r_p = grade_id.value("autograde_replacement_percentage",0.5); + + GRADEABLES[g].setResubmissionValues(token_key,o_id,r_id,t,a_r_p); + } + + assert (p_score >= a_score && + a_score >= b_score && + b_score >= c_score && + c_score >= d_score); + + assert (which >= 0 && which < GRADEABLES[g].getCount()); + if (GRADEABLES[g].isReleased(token_key)) { + perfect->setGradeableItemGrade(g,which, p_score); + lowest_a->setGradeableItemGrade(g,which, a_score); + lowest_b->setGradeableItemGrade(g,which, b_score); + lowest_c->setGradeableItemGrade(g,which, c_score); + lowest_d->setGradeableItemGrade(g,which, d_score); + } + + //std::cout << "it makes it to exam data" << std::endl; + + nlohmann::json exam_data = grade_id["exam_data"]; + //std::cout << exam_data << std::endl; + if (!exam_data.empty()) { + //std::cout << "makes it into exam data" << std::endl; + int active = exam_data["active"].get(); + if (active == 1) { + + GLOBAL_ACTIVE_TEST_ZONE = k; + + for (nlohmann::json::iterator itr2 = (exam_data).begin(); itr2 != (exam_data).end(); itr2++) { + std::string token2 = itr2.key(); + //std::cout << token2 << std::endl; + if (token2 == "exam_title") { + std::string value = itr2.value(); + GLOBAL_EXAM_TITLE = value; + } else if (token2 == "exam_date") { + std::string value = itr2.value(); + GLOBAL_EXAM_DATE = value; + } else if (token2 == "exam_time") { + std::string value = itr2.value(); + GLOBAL_EXAM_TIME = value; + } else if (token2 == "exam_default_room") { + std::string value = itr2.value(); + GLOBAL_EXAM_DEFAULT_ROOM = value; + } else if (token2 == "min_overall_for_zone_assignment") { + float value = itr2.value(); + GLOBAL_MIN_OVERALL_FOR_ZONE_ASSIGNMENT = value; + } else if (token2 == "exam_seating") { + std::cout << "TOKEN IS EXAM SEATING" << std::endl; + std::string value = itr2.value(); + GLOBAL_EXAM_SEATING = value; + } else if (token2 == "seating_spacing") { + std::cout << "TOKEN IS SEATING SPACING" << std::endl; + std::string value = itr2.value(); + GLOBAL_SEATING_SPACING = value; + } else if (token2 == "exam_seating_count") { + std::cout << "TOKEN IS EXAM SEATING COUNT" << std::endl; + std::string value = itr2.value(); + GLOBAL_EXAM_SEATING_COUNT = value; + } else if (token2 == "left_right_handedness") { + std::cout << "TOKEN IS LEFT RIGHT HANDEDNESS" << std::endl; + std::string value = itr2.value(); + GLOBAL_LEFT_RIGHT_HANDEDNESS = value; + } + } + } + } + } + } + students.push_back(perfect); + students.push_back(student_average); + students.push_back(student_stddev); + students.push_back(lowest_a); + students.push_back(lowest_b); + students.push_back(lowest_c); + students.push_back(lowest_d); + + //std::cout << "3" << std::endl; + + // get display optioons + std::vector displays = j["display"].get >(); + for (std::size_t i=0; i displayBenchmark = j["display_benchmark"].get >(); + for (std::size_t i=0; i= 0.0 && LATE_DAY_PERCENTAGE_PENALTY <= 0.5); + } else if (token == "test_improvement_averaging_adjustment") { + TEST_IMPROVEMENT_AVERAGING_ADJUSTMENT = true; + } else if (token == "quiz_normalize_and_drop") { + QUIZ_NORMALIZE_AND_DROP = itr.value(); + } else if (token == "lowest_test_counts_half") { + LOWEST_TEST_COUNTS_HALF = true; + } else { + std::cout << "ERROR: unknown use " << token << std::endl; + exit(0); + } + } + + //std::cout << "9" << std::endl; +} + + +void MakeRosterFile(std::vector &students) { + + std::sort(students.begin(),students.end(),by_name); + + std::ofstream ostr("./iclicker_Roster.txt"); + + + for (unsigned int i = 0; i < students.size(); i++) { + std::string foo = "active"; + if (students[i]->getLastName() == "") continue; + if (students[i]->getSection() <= 0 || students[i]->getSection() > 10) continue; + if (students[i]->getGradeableItemGrade(GRADEABLE_ENUM::TEST,0).getValue() < 1) { + //std::cout << "STUDENT DID NOT TAKE TEST 1 " << students[i]->getUserName() << std::endl; + foo = "inactive"; + } + std::string room = students[i]->getExamRoom(); + std::string zone = students[i]->getExamZone(); + if (room == "") room = "DCC 308"; + if (zone == "") zone = "SEE INSTRUCTOR"; + + + +#if 0 + ostr + << std::left << std::setw(15) << students[i]->getLastName() + << std::left << std::setw(13) << students[i]->getPreferredName() + << std::left << std::setw(12) << students[i]->getUserName() + << std::left << std::setw(12) << room + << std::left << std::setw(10) << zone + << std::endl; + + ostr + << students[i]->getLastName() << "," + << students[i]->getPreferredName() << "," + << students[i]->getUserName() << std::endl; + +#else + + ostr + << students[i]->getSection() << "\t" + << students[i]->getLastName() << "\t" + << students[i]->getPreferredName() << "\t" + << students[i]->getUserName() << "\t" + //<< foo + << std::endl; + +#endif + } + +} + + +// defined in zone.cpp +void LoadExamSeatingFile(const std::string &zone_counts_filename, + const std::string &zone_assignments_filename, + const std::string &seating_spacing, + const std::string &left_right_handedness, + std::vector &students); + +void load_student_grades(std::vector &students); + +void load_bonus_late_day(std::vector &students, int which_lecture, std::string bonus_late_day_file); + +void processcustomizationfile(std::vector &students) { + + + std::ifstream istr(CUSTOMIZATION_FILE.c_str()); + assert (istr.good()); + nlohmann::json j = nlohmann::json::parse(istr); + GLOBAL_CUSTOMIZATION_JSON = j; + + + SetBenchmarkPercentage("lowest_a-",0.9); + SetBenchmarkPercentage("lowest_b-",0.8); + SetBenchmarkPercentage("lowest_c-",0.7); + SetBenchmarkPercentage("lowest_d",0.6); + + SetBenchmarkColor("extracredit","aa88ff"); // dark purple + SetBenchmarkColor("perfect" ,"c8c8ff"); // purple + SetBenchmarkColor("lowest_a-" ,"c8ffc8"); // green + SetBenchmarkColor("lowest_b-" ,"ffffc8"); // yellow + SetBenchmarkColor("lowest_c-" ,"ffc8c8"); // orange + SetBenchmarkColor("lowest_d" ,"ff0000"); // red + SetBenchmarkColor("failing" ,"c80000"); // dark red + + preprocesscustomizationfile(students); + + load_student_grades(students); + + std::string token,token2; + + std::string iclicker_remotes_filename; + std::vector > > iclicker_questions(MAX_LECTURES+1); + + for (nlohmann::json::iterator itr = j.begin(); itr != j.end(); itr++) { + token = itr.key(); + //std::cout << token << std::endl; + if (token == "section") { + // create sections + int counter = 0; + for (nlohmann::json::iterator itr2 = (itr.value()).begin(); itr2 != (itr.value()).end(); itr2++) { + std::string temp = itr2.key(); + int section = std::stoi(temp); + std::string section_name = itr2.value(); + std::cout << "MAKE ASSOCIATION " << section << " " << section_name << std::endl; + //assert (!validSection(section)); + sectionNames[section] = section_name; + if (sectionColors.find(section_name) == sectionColors.end()) { + if (counter == 0) { + sectionColors[section_name] = "ccffcc"; // lt green + } else if (counter == 1) { + sectionColors[section_name] = "ffcccc"; // lt salmon + } else if (counter == 2) { + sectionColors[section_name] = "ffffaa"; // lt yellow + } else if (counter == 3) { + sectionColors[section_name] = "ccccff"; // lt blue-purple + } else if (counter == 4) { + sectionColors[section_name] = "aaffff"; // lt cyan + } else if (counter == 5) { + sectionColors[section_name] = "ffaaff"; // lt magenta + } else if (counter == 6) { + sectionColors[section_name] = "88ccff"; // blue + } else if (counter == 7) { + sectionColors[section_name] = "cc88ff"; // purple + } else if (counter == 8) { + sectionColors[section_name] = "88ffcc"; // mint + } else if (counter == 9) { + sectionColors[section_name] = "ccff88"; // yellow green + } else if (counter == 10) { + sectionColors[section_name] = "ff88cc"; // pink + } else if (counter == 11) { + sectionColors[section_name] = "ffcc88"; // orange + } else if (counter == 12) { + sectionColors[section_name] = "ffff33"; // yellow + } else if (counter == 13) { + sectionColors[section_name] = "ff33ff"; // magenta + } else if (counter == 14) { + sectionColors[section_name] = "33ffff"; // cyan + } else if (counter == 15) { + sectionColors[section_name] = "6666ff"; // blue-purple + } else if (counter == 16) { + sectionColors[section_name] = "66ff66"; // green + } else if (counter == 17) { + sectionColors[section_name] = "ff6666"; // red + } else { + sectionColors[section_name] = "aaaaaa"; // grey + } + counter++; + } + } + } else if (token == "messages") { + // general message at the top of the file + for (nlohmann::json::iterator itr2 = (itr.value()).begin(); itr2 != (itr.value()).end(); itr2++) { + MESSAGES.push_back(*itr2); + } + } else if (token == "warning") { + // EWS early warning system [ per student ] + std::vector warning_list = j[token].get >(); + for (std::size_t i = 0; i(); + std::string message = warning["msg"].get(); + std::vector ids; + float value = warning["value"].get(); + nlohmann::json j_ids = warning["ids"]; + for (std::size_t k = 0; k < j_ids.size(); k++) { + ids.push_back(j_ids[k].get()); + } + + std::cout << "search for " << message << std::endl; + for (std::size_t S = 0; S < students.size(); S++) { + Student *s = students[S]; + if (!validSection(students[S]->getSection())) continue; + //std::cout << "student " << s->getUserName() << std::endl; + float v = 0; + for (std::size_t k = 0; k < ids.size(); k++) { + GRADEABLE_ENUM g; + int item; + //std::cout << "GRADEABLE_ENUM " << (int)g << " " << item << std::endl; + LookupGradeable(ids[k],g,item); + v += s->getGradeableItemGrade(g,item).getValue(); + } + + if (v < value) { + std::stringstream ss; + ss << " " << v << " < " << value; + + s->addWarning(message + ss.str()); + } + } + + } + + } else if (token == "recommend") { + // UTA/mentor recommendations [ per student ] + std::vector recommend_list = j[token].get >(); + for (std::size_t i = 0; i < recommend_list.size(); i++) { + nlohmann::json recommend_user = recommend_list[i]; + std::string username = recommend_user["user"].get(); + std::string message = recommend_user["msg"].get(); + Student *s = GetStudent(students,username); + if (s == NULL) { + std::cout << username << std::endl; + } + assert (s != NULL); + s->addRecommendation(message); + } + } else if (token == "note") { + // other grading note [ per student ] + std::vector note_list = j[token].get >(); + for (std::size_t i = 0; i < note_list.size(); i++) { + nlohmann::json note_user = note_list[i]; + std::string username = note_user["user"].get(); + std::string message = note_user["msg"].get(); + Student *s = GetStudent(students,username); + if (s == NULL) { + std::cout << username << std::endl; + } + assert (s != NULL); + s->addNote(message); + } + } else if (token == "earned_late_days") { + DISPLAY_LATE_DAYS = true; + std::vector earnedLateDays = j[token].get >(); + GLOBAL_earned_late_days.clear(); + for (std::size_t i = 0; i < earnedLateDays.size(); i++) { + float tmp = earnedLateDays[i]; + assert (GLOBAL_earned_late_days.size() == 0 || tmp > GLOBAL_earned_late_days.back()); + GLOBAL_earned_late_days.push_back(tmp); + } + } else if (token == "iclicker_ids") { + iclicker_remotes_filename = itr.value(); + } else if (token == "iclicker") { + for (nlohmann::json::iterator itr2 = (itr.value()).begin(); itr2 != (itr.value()).end(); itr2++) { + std::string temp = itr2.key(); + std::vector iclickerLectures = j[token][temp]; + int which_lecture = std::stoi(temp); + + //Each step through this loop is one {} line inside a lecture, the naming of lecture vs lectures here is confusing + for (std::size_t i = 0; i < iclickerLectures.size(); i++) { + nlohmann::json iclickerLecture = iclickerLectures[i]; + iclicker_questions[which_lecture].push_back(std::vector()); + + + int which_column = iclickerLecture["column"].get(); + std::string correct_answer = iclickerLecture["answer"].get(); + assert (which_lecture >= 1 && which_lecture <= MAX_LECTURES); + + + //Code to support multiple iClicker files for one question + nlohmann::json j_filenames = iclickerLecture["file"]; + std::vector filenames; + for (std::size_t k = 0; k < j_filenames.size(); k++) { + filenames.push_back(j_filenames[k].get()); + } + + for (std::size_t k=0; k audit_list = itr.value(); + for (std::size_t i = 0; i < audit_list.size(); i++) { + std::string username = audit_list[i]; + Student *s = GetStudent(students,username); + assert (s != NULL); + assert (s->getAudit() == false); + s->setAudit(); + s->addNote("AUDIT"); + } + } else if (token == "withdraw") { + std::vector withdraw_list = itr.value(); + for (std::size_t i = 0; i < withdraw_list.size(); i++) { + std::string username = withdraw_list[i]; + Student *s = GetStudent(students,username); + assert (s != NULL); + assert (s->getWithdraw() == false); + s->setWithdraw(); + s->addNote("LATE WITHDRAW"); + } + } else if (token == "independentstudy") { + std::vector independent_study_list = itr.value(); + for (std::size_t i = 0; i < independent_study_list.size(); i++) { + std::string username = independent_study_list[i]; + Student *s = GetStudent(students,username); + assert (s != NULL); + assert (s->getIndependentStudy() == false); + s->setIndependentStudy(); + s->addNote("INDEPENDENT STUDY"); + } + } else if (token == "manual_grade") { + for (nlohmann::json::iterator itr2 = (itr.value()).begin(); itr2 != (itr.value()).end(); itr2++) { + + std::string username = (itr2.value())["user"].get(); + std::string grade = (itr2.value())["grade"].get(); + std::string note = (itr2.value())["note"].get(); + + Student *s = GetStudent(students,username); + assert (s != NULL); + s->ManualGrade(grade,note); + } + } else if (token == "plagiarism") { + for (nlohmann::json::iterator itr2 = (itr.value()).begin(); itr2 != (itr.value()).end(); itr2++) { + std::string username = (itr2.value())["user"].get(); + std::string hw = (itr2.value())["gradeable"].get(); + float penalty = (itr2.value())["penalty"].get(); + //assert (hw >= 1 && hw <= 10); + assert (penalty >= -0.01 && penalty <= 1.01); + Student *s = GetStudent(students,username); + assert (s != NULL); + s->mossify(hw,penalty); + } + } else if (token == "final_cutoff") { + for (nlohmann::json::iterator itr2 = (itr.value()).begin(); itr2 != (itr.value()).end(); itr2++) { + std::string grade = itr2.key(); + float cutoff = itr2.value(); + assert (grade == "A" || + grade == "A-" || + grade == "B+" || + grade == "B" || + grade == "B-" || + grade == "C+" || + grade == "C" || + grade == "C-" || + grade == "D+" || + grade == "D"); + CUTOFFS[grade] = cutoff; + } + } else if (token == "gradeables") { + continue; + } else if (token == "bonus_latedays") { + nlohmann::json bonusJson = j[token]; + for (nlohmann::json::iterator itr2 = bonusJson.begin(); itr2 != bonusJson.end(); itr2++) { + std::string bonus = itr2.key(); + BONUS_WHICH_LECTURE = std::stoi(bonus); + BONUS_FILE = j[token][bonus]; + std::cout << "BONUS LATE DAYS" << std::endl; + + if (BONUS_FILE != "") { + load_bonus_late_day(students,BONUS_WHICH_LECTURE,BONUS_FILE); + } + } + } else { + if (token == "display" || token == "display_benchmark" || token == "benchmark_percent") { + continue; + } else if (token == "use" || token == "hackmaxprojects" || token == "benchmark_color") { + continue; + } + std::cout << "ERROR: UNKNOWN TOKEN X " << token << std::endl; + } + } + + if (GLOBAL_EXAM_SEATING_COUNT != "" && GLOBAL_EXAM_SEATING != "") { + LoadExamSeatingFile(GLOBAL_EXAM_SEATING_COUNT,GLOBAL_EXAM_SEATING,GLOBAL_SEATING_SPACING,GLOBAL_LEFT_RIGHT_HANDEDNESS,students); + } + MakeRosterFile(students); + MatchClickerRemotes(students, iclicker_remotes_filename); + AddClickerScores(students,iclicker_questions); +} + + + +void load_student_grades(std::vector &students) { + + Student *perfect = GetStudent(students,"PERFECT"); + assert (perfect != NULL); + + Student *student_average = GetStudent(students,"AVERAGE"); + assert (student_average != NULL); + + Student *student_stddev = GetStudent(students,"STDDEV"); + assert (student_stddev != NULL); + + + std::string command2 = "ls -1 " + RAW_DATA_DIRECTORY + "*.json > files_json.txt"; + + system(command2.c_str()); + + std::ifstream files_istr("files_json.txt"); + assert(files_istr); + std::string filename; + int count = 0; + while (files_istr >> filename) { + std::ifstream istr(filename.c_str()); + assert(istr.good()); + nlohmann::json j = nlohmann::json::parse(istr); + + Student *s = new Student(); + + count++; + + std::ifstream customization_istr(CUSTOMIZATION_FILE.c_str()); + assert (customization_istr.good()); + nlohmann::json customization_j = nlohmann::json::parse(customization_istr); + + std::string participation_gradeable_id = ""; + std::string participation_component = ""; + std::string understanding_gradeable_id = ""; + std::string understanding_component = ""; + std::string recommendation_gradeable_id = ""; + std::string recommendation_text = ""; + + if (customization_j.find("participation") != customization_j.end()) { + participation_gradeable_id = customization_j["participation"]["id"].get(); + participation_component = customization_j["participation"]["component"].get(); + } + if (customization_j.find("understanding") != customization_j.end()) { + understanding_gradeable_id = customization_j["understanding"]["id"].get(); + understanding_component = customization_j["understanding"]["component"].get(); + } + if (customization_j.find("recommendation") != customization_j.end()) { + recommendation_gradeable_id = customization_j["recommendation"]["id"].get(); + recommendation_text = customization_j["recommendation"]["text"].get(); + } + + for (nlohmann::json::iterator itr = j.begin(); itr != j.end(); itr++) { + std::string token = itr.key(); + // std::cout << "token: " << token << "!" << std::endl; + GRADEABLE_ENUM g; + bool gradeable_enum_success = string_to_gradeable_enum(token,g); + if (!gradeable_enum_success && token != "Other" && token != "rubric" && token != "Test") { + // non gradeables + if (token == "user_id") { + s->setUserName(j[token].get()); + } else if (token == "legal_first_name") { + s->setLegalFirstName(j[token].get()); + } else if (token == "preferred_first_name") { + if (!j[token].is_null()) { + s->setPreferredFirstName(j[token].get()); + } + } else if (token == "last_name") { + s->setLastName(j[token].get()); + } else if (token == "last_update") { + s->setLastUpdate(j[token].get()); + } else if (token == "registration_section") { + int a; + if(!j[token].is_null()) { + a = j[token].get(); + if (!validSection(a)) { + // the "drop" section is 0 (really should be NULL) + if (a != 0) { + std::cerr << "WARNING: invalid section " << a << std::endl; + } + } + } + else{ + a = 0; + } + s->setSection(a); + + } else if (token == "default_allowed_late_days") { + int value = 0; + if (!j[token].is_null()) { + if (j[token].is_string()) { + std::string s_value = j[token].get(); + value = std::stoi(s_value); + } else { + value = j[token].get(); + } + } + s->setDefaultAllowedLateDays(value); + if (value > 0) { + DISPLAY_LATE_DAYS = true; + } + } else { + std::cout << "UNKNOWN TOKEN Y '" << token << "'" << std::endl; + exit(0); + } + } else { + for (nlohmann::json::iterator itr2 = (itr.value()).begin(); itr2 != (itr.value()).end(); itr2++) { + int which; + bool invalid = false; + std::string gradeable_id = (*itr2).value("id","ERROR BAD ID"); + std::string gradeable_name = (*itr2).value("name",gradeable_id); + std::string status; + if (itr2 != (itr.value()).end() && (*itr2).is_string()) { + status = (*itr2).value("status","NOT ELECTRONIC"); + } else { + status = "NO SUBMISSION"; + } + float score = (*itr2).value("score",0.0); + if (status.find("Bad") != std::string::npos) { + assert (score == 0); + } else { + assert (status == "NO SUBMISSION" || status == "NOT ELECTRONIC" || status == "Good" || status == "Late"); + } + + std::string other_note = ""; + nlohmann::json::iterator itr3 = itr2->find("components"); + if (itr3 != itr2->end()) { + for (std::size_t i = 0; i < itr3->size(); i++) { + std::string component_title = "placeholder"; + assert ((*itr3)[i].find("title") != (*itr3)[i].end()); + if ((*itr3)[i].find("title")->is_string()) { + component_title = (*itr3)[i].value("title",""); + } else { + // title is sometimes a number... convert to string + assert ((*itr3)[i].find("title")->is_number()); + component_title = std::to_string((*itr3)[i].value("title",0)); + } + std::string component_comment = (*itr3)[i].value("comment",""); + if (component_title == "Notes" && component_comment != "") { + other_note += " " + component_comment; + } + } + } + + // Search through the gradeable categories as needed to find where this item belongs + // (e.g. project may be prefixed by "hw", or exam may be prefixed by "test") + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + GRADEABLE_ENUM g2 = ALL_GRADEABLES[i]; + if (GRADEABLES[g2].hasCorrespondence(gradeable_id)) { + g = g2; + } + } + if (!GRADEABLES[g].hasCorrespondence(gradeable_id)) { + invalid = true; + //std::cerr << "ERROR! cannot find a category for this item " << gradeable_id << std::endl; + } else { + invalid = false; + const std::pair& c = GRADEABLES[g].getCorrespondence(gradeable_id); + which = c.first; + if (c.second == "") { + GRADEABLES[g].setCorrespondenceName(gradeable_id,gradeable_name); + } else { + assert (c.second == gradeable_name); + } + } + + if (gradeable_id == GLOBAL_recommend_id) { + nlohmann::json::iterator rec = itr2->find("text"); + if (rec != itr2->end()) { + for (std::size_t i = 0; i < (*rec).size(); i++) { + for (auto itr8 = (*rec)[i].begin(); itr8 != (*rec)[i].end(); itr8++) { + std::string r = itr8.value(); + s->addRecommendation(std::string(" ") + r); + } + } + } + } + + if (!invalid) { + assert (which >= 0); + assert (score >= 0.0); + int late_days_charged = itr2->value("days_charged",0); + if (itr3 != itr2->end()) { + if (score <= 0) { + if (s->getUserName() != "") { + assert (late_days_charged == 0); + } + } + } + float clamp = -1; + clamp = GRADEABLES[g].getClamp(gradeable_id); + if (clamp > 0) { + score = std::min(clamp,score); + } + if (status.find("Bad") != std::string::npos) { + assert (late_days_charged == 0); + } + if (GRADEABLES[g].isReleased(gradeable_id)) { + s->setGradeableItemGrade(g,which,score,late_days_charged,other_note,status); + } + } + + } + } + } + + float participation = 0; + float understanding = 0; + std::string recommendation; + if (participation_gradeable_id != "") { + std::vector notes = j["Note"]; + for (int x = 0; x < notes.size(); x++) { + if (notes[x]["id"] == participation_gradeable_id) { + nlohmann::json scores = notes[x]["component_scores"]; + for (int y = 0; y < scores.size(); y++) { + if (scores[y].find(participation_component) != scores[y].end()) { + participation = scores[y][participation_component].get(); + } + } + } + } + } + if (understanding_gradeable_id != "") { + std::vector notes = j["Note"]; + for (int x = 0; x < notes.size(); x++) { + if (notes[x]["id"] == understanding_gradeable_id) { + nlohmann::json scores = notes[x]["component_scores"]; + for (int y = 0; y < scores.size(); y++) { + if (scores[y].find(understanding_component) != scores[y].end()) { + understanding = scores[y][understanding_component].get(); + } + } + } + } + } + if (recommendation_gradeable_id != "") { + std::vector notes = j["Note"]; + for (int x = 0; x < notes.size(); x++) { + if (notes[x]["id"] == recommendation_gradeable_id) { + nlohmann::json values = notes[x]["text"]; + for (int y = 0; y < values.size(); y++) { + if (values[y].find(recommendation_text) != values[y].end()) { + if (values[y][recommendation_text].is_string()) { + recommendation = values[y][recommendation_text].get(); + } else { + std::cout << "error in recommendation text type for " << s->getUserName() << std::endl; + } + } + } + } + } + } + + s->setParticipation(participation); + s->setUnderstanding(understanding); + if (recommendation != "") { + s->addRecommendation(recommendation); + } + + + // lookup and compute resubmit/replacement gradeable items + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + for (int which = 0; which < GRADEABLES[g].getCount(); which++) { + std::string original_id; + std::string resubmit_id; + float autograde_replacement_percentage; + GRADEABLES[g].isResubmit(which,original_id,resubmit_id,autograde_replacement_percentage); + if (original_id == "") continue; + + float original_autograde = 0; + float original_tagrade = 0; + float resubmit_autograde = 0; + + for (nlohmann::json::iterator itr = j.begin(); itr != j.end(); itr++) { + std::string token = itr.key(); + + if (itr.value().is_array()) { + for (int e = 0; e < itr.value().size(); e++) { + if (!itr.value()[e].is_object()) continue; + if (itr.value()[e].value("id","") == original_id) { + original_autograde = itr.value()[e].value("autograding_score",0.0); + original_tagrade = itr.value()[e].value("tagrading_score",0.0); + + // WORKAROUND -- bug in gradesummaries tagrading for unsubmitted assignment + // ALSO NEED TO DEAL WITH VERSION CONFLICTS BETTER + float original_score = itr.value()[e].value("score",0.0); + if (original_score < original_tagrade + original_autograde) { + original_tagrade = 0; + original_autograde = 0; + } + //std::cout << "student " << std::left << std::setw(10) << s->getUserName() << std::endl; + //std::cout << " CHECK " << original_score << " " << original_autograde << " " << original_tagrade << std::endl; + assert (fabs( original_score -( original_autograde + original_tagrade)) < 0.1); + // END WORKAROUND + + } + if (itr.value()[e].value("id","") == resubmit_id) { + resubmit_autograde = itr.value()[e].value("autograding_score",0); + // SIMILAR WORKAROUND + float resubmit_score = itr.value()[e].value("score",0); + if (resubmit_score == 0) { + resubmit_autograde = 0; + } + // END WORKAROUND + + } + } + } + } + float new_autograde = + original_autograde*(1-autograde_replacement_percentage) + + resubmit_autograde*(autograde_replacement_percentage); + float score = + original_tagrade + + std::max(original_autograde,new_autograde); + if (original_autograde < new_autograde) { + std::cout << "student " << std::left << std::setw(10) << s->getUserName() << " had grade increase for "; + std::cout << original_id << ": " + << std::right << std::setw(5) << original_tagrade << " + " + << std::right << std::setw(5) << original_autograde << " / " + << std::right << std::setw(5) << resubmit_autograde << " -> " + << std::right << std::setw(5) << new_autograde << " = " + << std::right << std::setw(5) << score << std::endl; + } + s->setGradeableItemGrade(g,which,score); + } + } + + students.push_back(s); + } + +} + + +void start_table_open_file(bool full_details, + const std::vector &students, int S, int month, int day, int year, + enum GRADEABLE_ENUM which_gradeable_enum); + +void start_table_output(bool full_details, + const std::vector &students, int S, int month, int day, int year, + Student *sp, Student *sa, Student *sb, Student *sc, Student *sd); + +void end_table(std::ofstream &ostr, bool full_details, Student *s); + + + +// ============================================================================================= +// ============================================================================================= +// ============================================================================================= + + + +void output_helper(std::vector &students, std::string &GLOBAL_sort_order) { + + Student *sp = GetStudent(students,"PERFECT"); + Student *student_average = GetStudent(students,"AVERAGE"); + Student *student_stddev = GetStudent(students,"STDDEV"); + Student *sa = GetStudent(students,"LOWEST A-"); + Student *sb = GetStudent(students,"LOWEST B-"); + Student *sc = GetStudent(students,"LOWEST C-"); + Student *sd = GetStudent(students,"LOWEST D"); + assert (sp != NULL); + assert (student_average != NULL); + assert (student_stddev != NULL); + assert (sa != NULL); + assert (sb != NULL); + assert (sc != NULL); + assert (sd != NULL); + + std::string command = "rm -f " + OUTPUT_FILE + " " + INDIVIDUAL_FILES_OUTPUT_DIRECTORY + "*html"; + system(command.c_str()); + command = "rm -f " + OUTPUT_FILE + " " + INDIVIDUAL_FILES_OUTPUT_DIRECTORY + "*json"; + system(command.c_str()); + + // get todays date; + time_t now = time(0); + struct tm * now2 = localtime( & now ); + int month = now2->tm_mon+1; + int day = now2->tm_mday; + int year = now2->tm_year+1900; + + start_table_open_file(true,students,-1,month,day,year,GRADEABLE_ENUM::NONE); + start_table_output(true,students,-1,month,day,year, sp,sa,sb,sc,sd); + + int next_rank = 1; + int last_section = -1; + + for (int S = 0; S < (int)students.size(); S++) { + //int rank = next_rank; + if (students[S] == sp || + students[S] == student_average || + students[S] == student_stddev || + students[S] == sa || + students[S] == sb || + students[S] == sc || + students[S] == sd || + // students[S]->getUserName() == "" || + !validSection(students[S]->getSection())) { + //rank = -1; + } else { + if (GLOBAL_sort_order == std::string("by_section") && + last_section != students[S]->getSection()) { + last_section = students[S]->getSection(); + //next_rank = rank = 1; + next_rank = 1; + } + next_rank++; + } + Student *this_student = students[S]; + assert (this_student != NULL); + } + + + for (int S = 0; S < (int)students.size(); S++) { + + nlohmann::json mj; + + std::string file2 = INDIVIDUAL_FILES_OUTPUT_DIRECTORY + students[S]->getUserName() + "_message.html"; + std::string file2_json = INDIVIDUAL_FILES_OUTPUT_DIRECTORY + students[S]->getUserName() + "_message.json"; + std::ofstream ostr2(file2.c_str()); + std::ofstream ostr2_json(file2_json.c_str()); + + mj["username"] = students[S]->getUserName(); + mj["building"] = "DCC"; + mj["room"] = "308"; + mj["zone"] = "A"; + + ostr2_json << mj.dump(4); + + +#if 0 + if (students[S]->hasPriorityHelpStatus()) { + ostr2 << "

PRIORITY HELP QUEUE

" << std::endl; + priority_stream << std::left << std::setw(15) << students[S]->getSection() + << std::left << std::setw(15) << students[S]->getUserName() + << std::left << std::setw(15) << students[S]->getPreferredName() + << std::left << std::setw(15) << students[S]->getLastName() << std::endl; + + + } + + if (MAX_ICLICKER_TOTAL > 0) { + ostr2 << "recent iclicker = " << students[S]->getIClickerRecent() << " / 12.0" << std::endl; + } +#endif + + + nlohmann::json::iterator special_message_itr = GLOBAL_CUSTOMIZATION_JSON.find("special_message"); + nlohmann::json special_message; + if (special_message_itr != GLOBAL_CUSTOMIZATION_JSON.end()) { + special_message = *special_message_itr; + } + + PrintExamRoomAndZoneTable(ostr2,students[S],special_message); + + int prev = students[S]->getAllowedLateDays(0); + + for (int i = 1; i <= MAX_LECTURES; i++) { + int tmp = students[S]->getAllowedLateDays(i); + if (prev != tmp) { + + std::map::iterator itr = LECTURE_DATE_CORRESPONDENCES.find(i); + if (itr == LECTURE_DATE_CORRESPONDENCES.end()) { + continue; + } + Date &d = itr->second; + late_days_stream << students[S]->getUserName() << "," + << d.getStringRep() << "," + << tmp << std::endl; + prev = tmp; + } + } + } +} + + +// ============================================================================================= +// ============================================================================================= +// ============================================================================================= + +void load_bonus_late_day(std::vector &students, + int which_lecture, + std::string bonus_late_day_file) { + + std::cout << "LOAD BONUS LATE" << std::endl; + + std::ifstream istr(bonus_late_day_file.c_str()); + if (!istr.good()) { + std::cerr << "ERROR! could not open " << bonus_late_day_file << std::endl; + exit(1); + } + + std::string username; + while (istr >> username) { + Student *s = GetStudent(students,username); + if (s == NULL) { + //std::cerr << "ERROR! bad username " << username << " cannot give bonus late day " << std::endl; + //exit(1); + } else { + //std::cout << "BONUS DAY FOR USER " << username << std::endl; + s->add_bonus_late_day(which_lecture); + //std::cout << "add bonus late day for " << username << std::endl; + } + } + +} + + + +int main(int argc, char* argv[]) { + + //std::string sort_order = "by_overall"; + + if (argc > 1) { + assert (argc == 2); + GLOBAL_sort_order = argv[1]; + } + + std::vector students; + processcustomizationfile(students); + + // ====================================================================== + // SUGGEST CURVES + suggest_curves(students); + + // ====================================================================== + // SORT + std::sort(students.begin(),students.end(),by_overall); + + + if (GLOBAL_sort_order == std::string("by_overall")) { + std::sort(students.begin(),students.end(),by_overall); + } else if (GLOBAL_sort_order == std::string("by_name")) { + std::sort(students.begin(),students.end(),by_name); + } else if (GLOBAL_sort_order == std::string("by_section")) { + std::sort(students.begin(),students.end(),by_section); + } else if (GLOBAL_sort_order == std::string("by_zone")) { + + DISPLAY_INSTRUCTOR_NOTES = false; + DISPLAY_EXAM_SEATING = true; + DISPLAY_MOSS_DETAILS = false; + DISPLAY_FINAL_GRADE = false; + DISPLAY_GRADE_SUMMARY = false; + DISPLAY_GRADE_DETAILS = false; + DISPLAY_ICLICKER = false; + + std::sort(students.begin(),students.end(),by_name); + + } else if (GLOBAL_sort_order == std::string("by_iclicker")) { + std::sort(students.begin(),students.end(),by_iclicker); + + DISPLAY_ICLICKER = true; + + } else if (GLOBAL_sort_order == std::string("by_test_and_exam")) { + std::sort(students.begin(),students.end(),by_test_and_exam); + + } else { + assert (GLOBAL_sort_order.size() > 3); + GRADEABLE_ENUM g; + // take off "by_" + std::string tmp = GLOBAL_sort_order.substr(3,GLOBAL_sort_order.size()-3); + bool success = string_to_gradeable_enum(tmp,g); + if (success) { + std::sort(students.begin(),students.end(), GradeableSorter(g) ); + } + else { + std::cerr << "UNKNOWN SORT OPTION " << GLOBAL_sort_order << std::endl; + std::cerr << " Usage: " << argv[0] << " [ by_overall | by_name | by_section | by_zone | by_iclicker | by_lab | by_exercise | by_reading | by_hw | by_test | by_exam | by_test_and_exam ]" << std::endl; + exit(1); + } + } + + + + // ====================================================================== + // COUNT + + for (unsigned int s = 0; s < students.size(); s++) { + + Student *this_student = students[s]; + + if (this_student->getLastName() == "" || this_student->getFirstName() == "") { + continue; + } + if (this_student->getAudit()) { + auditors++; + continue; + } + + Student *sd = GetStudent(students,"LOWEST D"); + + if (validSection(this_student->getSection())) { + std::string student_grade = this_student->grade(false,sd); + grade_counts[student_grade]++; + grade_avg[student_grade]+=this_student->overall(); + } else { + dropped++; + } + if (GRADEABLES[GRADEABLE_ENUM::EXAM].getCount() != 0) { + if (this_student->getGradeableItemGrade(GRADEABLE_ENUM::EXAM,GRADEABLES[GRADEABLE_ENUM::EXAM].getCount()-1).getValue() > 0) { + took_final++; + } + } + + } + + int runningtotal = 0; + for (std::map::iterator itr = grade_counts.begin(); + itr != grade_counts.end(); itr++) { + runningtotal += itr->second; + + grade_avg[itr->first] /= float(itr->second); + } + + // ====================================================================== + // OUTPUT + + output_helper(students,GLOBAL_sort_order); + +} + + +void suggest_curves(std::vector &students) { + + Student *student_average = GetStudent(students,"AVERAGE"); + Student *student_stddev = GetStudent(students,"STDDEV"); + + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + + for (int item = 0; item < GRADEABLES[g].getCount(); item++) { + + std::string gradeable_id = GRADEABLES[g].getID(item); + if (gradeable_id == "") continue; + + const std::string& gradeable_name = GRADEABLES[g].getCorrespondence(gradeable_id).second; + + std::cout << gradeable_to_string(g) << " " << gradeable_id << " " << gradeable_name/* << " statistics & suggested curve"*/ << std::endl; + std::vector scores; + + std::map section_counts; + + for (unsigned int S = 0; S < students.size(); S++) { + if (students[S]->getSection() > 0 && students[S]->getGradeableItemGrade(g,item).getValue() > 0) { + scores.push_back(students[S]->getGradeableItemGrade(g,item).getValue()); + section_counts[students[S]->getSection()]++; + } + } + if (scores.size() > 0) { + //std::cout << " " << scores.size() << " submitted" << std::endl; + std::sort(scores.begin(),scores.end()); + float sum = 0; + for (unsigned int x = 0; x < scores.size(); x++) { + sum+=scores[x]; + } + float average = sum / float(scores.size()); + std::cout << " average=" << std::setprecision(2) << std::fixed << average; + + student_average->setGradeableItemGrade(g,item,average); + + sum = 0; + for (unsigned int x = 0; x < scores.size(); x++) { + sum+=(average-scores[x])*(average-scores[x]); + } + float stddev = sqrt(sum/float(scores.size())); + std::cout << " stddev=" << std::setprecision(2) << std::fixed << stddev; + student_stddev->setGradeableItemGrade(g,item,stddev); + + std::cout << " suggested curve:"; + + std::cout << " A- cutoff=" << scores[int(0.70*scores.size())]; + std::cout << " B- cutoff=" << scores[int(0.45*scores.size())]; + std::cout << " C- cutoff=" << scores[int(0.20*scores.size())]; + std::cout << " D cutoff=" << scores[int(0.10*scores.size())]; + std::cout << std::endl; + } + + + int total = 0; + std::cout << " "; + for (std::map::iterator itr = section_counts.begin(); itr != section_counts.end(); itr++) { + std::cout << " sec#" << itr->first << "=" << itr->second << " "; + total += itr->second; + } + std::cout << " TOTAL = " << total << std::endl; + } + } +} + +// ============================================================================================= +// ============================================================================================= +// ============================================================================================= + diff --git a/output.cpp b/output.cpp new file mode 100644 index 0000000..534d5a4 --- /dev/null +++ b/output.cpp @@ -0,0 +1,1234 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "student.h" +#include "iclicker.h" +#include "grade.h" +#include "table.h" +#include "benchmark.h" + +#include + +#define grey_divider "aaaaaa" + +#include "constants_and_globals.h" + +extern std::string OUTPUT_FILE; +extern std::string ALL_STUDENTS_OUTPUT_DIRECTORY; + +extern Student* AVERAGE_STUDENT_POINTER; +extern Student* STDDEV_STUDENT_POINTER; + +extern std::string GLOBAL_sort_order; + +extern int GLOBAL_ACTIVE_TEST_ZONE; + +// ========================================================== + +std::string HEX(int h) { + std::stringstream ss; + ss << std::hex << std::setw(2) << std::setfill('0') << h; + return ss.str(); +} + +int UNHEX(std::string s) { + assert (s.size() == 2); + int h; + std::stringstream ss(s); + ss >> std::hex >> h; + assert (h >= 0 && h <= 255); + return h; +} + + +// colors for grades +const std::string GradeColor(const std::string &grade) { + if (grade == "A" ) return HEX(200)+HEX(200)+HEX(255); + else if (grade == "A-") return HEX(200)+HEX(235)+HEX(255); + else if (grade == "B+") return HEX(219)+HEX(255)+HEX(200); + else if (grade == "B" ) return HEX(237)+HEX(255)+HEX(200); + else if (grade == "B-") return HEX(255)+HEX(255)+HEX(200); + else if (grade == "C+") return HEX(255)+HEX(237)+HEX(200); + else if (grade == "C" ) return HEX(255)+HEX(219)+HEX(200); + else if (grade == "C-") return HEX(255)+HEX(200)+HEX(200); + else if (grade == "D+") return HEX(255)+HEX(100)+HEX(100); + else if (grade == "D" ) return HEX(255)+HEX( 0)+HEX( 0); + else if (grade == "F" ) return HEX(200)+HEX( 0)+HEX( 0); + else return "ffffff"; +} + +// ========================================================== + +float compute_average(const std::vector &vals) { + assert (vals.size() > 0); + float total = 0; + for (std::size_t i = 0; i < vals.size(); i++) { + total += vals[i]; + } + return total / float (vals.size()); +} + + +float compute_stddev(const std::vector &vals, float average) { + assert (vals.size() > 0); + float total = 0; + for (std::size_t i = 0; i < vals.size(); i++) { + total += (vals[i]-average)*(vals[i]-average); + } + return sqrt(total / float (vals.size()) ); +} + +// ========================================================== + +int convertYear(const std::string &major) { + if (major == "FR") return 1; + if (major == "SO") return 2; + if (major == "JR") return 3; + if (major == "SR") return 4; + if (major == "FY") return 5; + if (major == "GR") return 6; + else return 10; +} + +int convertMajor(const std::string &major) { + if (major == "CSCI") return 20; + if (major == "ITWS" || major == "ITEC") return 19; + if (major == "CSYS") return 18; + if (major == "GSAS") return 17; + if (major == "MATH") return 16; + if (major == "COGS" || major == "PSYC") return 15; + if (major == "ELEC") return 14; + if (major == "PHYS" || major == "APHY") return 13; + if (major == "BMGT" || + major == "ISCI" || + major == "ENGR" || + major == "USCI" || + major == "DSIS" || + major == "ECON" || + major == "EART" || + major == "CHEG" || + major == "MECL" || + major == "MGTE" || + major == "UNGS" || + major == "BMED" || + major == "MECL" || + major == "BFMB" || + major == "ARCH" || + major == "FERA" || + major == "CHEM" || + major == "MGMT" || + major == "NUCL" || + major == "MATL" || + major == "") return 0; + else return 10; +} + +// ========================================================== + +class Color { +public: + Color(int r_=0, int g_=0, int b_=0) : r(r_),g(g_),b(b_) {} + Color(const std::string& s) { + r = UNHEX(s.substr(0,2)); + g = UNHEX(s.substr(2,2)); + b = UNHEX(s.substr(4,2)); + } + int r,g,b; +}; + +std::string coloritcolor(float val, + float perfect, + float a, + float b, + float c, + float d) { + + //check for nan + if (val != val) return "ffffff"; + if (std::isinf(val)) return "00ff00"; + + //std::cout << "coloritcolor " << val << " " << perfect << " " << a << " " << b << " " << c << " " << d << std::endl; + assert (perfect >= a && + a >= b && + b >= c && + c >= d && + d >= 0); + + if (val < 0.00001) return "ffffff"; + else if (val > perfect) return GetBenchmarkColor("extracredit"); + else { + float alpha; + Color c1,c2; + + static Color perfect_color(GetBenchmarkColor("perfect")); + static Color a_color(GetBenchmarkColor("lowest_a-")); + static Color b_color(GetBenchmarkColor("lowest_b-")); + static Color c_color(GetBenchmarkColor("lowest_c-")); + static Color d_color(GetBenchmarkColor("lowest_d")); + + if (val >= a) { + if (fabs(perfect-a) < 0.0001) alpha = 0; + else alpha = (perfect-val)/float(perfect-a); + c1 = perfect_color; + c2 = a_color; + } + else if (val >= b) { + if (fabs(a-b) < 0.0001) alpha = 0; + else alpha = (a-val)/float(a-b); + c1 = a_color; + c2 = b_color; + } + else if (val >= c) { + if (fabs(b-c) < 0.0001) alpha = 0; + else alpha = (b-val)/float(b-c); + c1 = b_color; + c2 = c_color; + } + else if (val >= d) { + if (fabs(c-d) < 0.0001) alpha = 0; + else alpha = (c-val)/float(c-d); + c1 = c_color; + c2 = d_color; + } + else { + return GetBenchmarkColor("failing"); + } + + float red = (1-alpha) * c1.r + (alpha) * c2.r; + float green = (1-alpha) * c1.g + (alpha) * c2.g; + float blue = (1-alpha) * c1.b + (alpha) * c2.b; + + return HEX(red) + HEX(green) + HEX(blue); + + } +} + +void coloritcolor(std::ostream &ostr, + float val, + float perfect, + float a, + float b, + float c, + float d) { + ostr << coloritcolor(val,perfect,a,b,c,d); +} + +void colorit_year(std::ostream &ostr, const std::string& s) { + if (s == "FR") { + ostr << "" << s << ""; + } else if (s == "SO") { + ostr << "" << s << ""; + } else if (s == "JR") { + ostr << "" << s << ""; + } else if (s == "SR") { + ostr << "" << s << ""; + } else if (s == "GR") { + ostr << "" << s << ""; + } else if (s == "FY") { + ostr << "" << s << ""; + } else if (s == "") { + ostr << " "; + } else { + std::cout << "EXIT " << s << std::endl; + exit(0); + } +} + + + +void colorit_major(std::ostream &ostr, const std::string& s) { + int m = convertMajor(s); + ostr << "" << s << ""; +} + + + +void colorit_section(std::ostream &ostr, + int section, bool for_instructor, const std::string &color) { + + std::string section_name; + + if (validSection(section)) + section_name = sectionNames[section]; + std::string section_color = sectionColors[section_name]; + + if (section == 0) { + section_color=color; + } + + if (for_instructor) { + if (section != 0) { + ostr << "" << section << " (" << section_name << ")"; + } else { + ostr << " " << std::endl; + } + } else { + if (section != 0) { + ostr << "" << section << ""; + } else { + ostr << " " << std::endl; + } + } + +} + +void colorit_section2(int section, std::string &color, std::string &label) { + std::string section_name; + if (validSection(section)) { + section_name = sectionNames[section]; + color = sectionColors[section_name]; + std::stringstream ss; + ss << section << " (" << sectionNames[section] << ")"; + label = ss.str(); + } +} + + + +void colorit(std::ostream &ostr, + float val, + float perfect, + float a, + float b, + float c, + float d, + int precision=1, + bool centered=false, + std::string bonus_text="") { + if (centered) + ostr << ""; + if (val < 0.0000001) { + ostr << " "; + } else if (precision == 1) { + ostr << std::dec << val << " " << bonus_text; + } else { + assert (precision == 0); + ostr << std::dec << (int)val; + } + ostr << ""; +} + +// ========================================================== + +void PrintExamRoomAndZoneTable(std::ofstream &ostr, Student *s, const nlohmann::json &special_message) { + + if (special_message.size() > 0) { + + ostr << "\n"; + ostr << "\n"; + ostr << "
\n"; + ostr << "\n"; + + assert (special_message.find("title") != special_message.end()); + std::string title = special_message.value("title","MISSING TITLE"); + + assert (special_message.find("description") != special_message.end()); + std::string description = special_message.value("description","provided_files.zip"); + + ostr << "

" << title << "

" << std::endl; + + assert (special_message.find("files") != special_message.end()); + nlohmann::json files = *(special_message.find("files")); + int num_files = files.size(); + assert (num_files >= 1); + + std::string username = s->getUserName(); + int A = 54059; /* a prime */ + int B = 76963; /* another prime */ + int FIRSTH = 37; /* also prime */ + + unsigned int tmp = FIRSTH; + for (std::size_t i = 0; i < username.size(); i++) { + tmp = (tmp * A) ^ (username[i] * B); + s++; + } + + int which = (tmp % num_files)+1; + std::string filename = files.value(std::to_string(which),""); + assert (filename != ""); + + ostr << " \n"; + ostr << "
" << description << "
\n"; + ostr << "
\n"; + } + + // ============================================================== + + + if ( DISPLAY_EXAM_SEATING == false) return; + + std::string room = GLOBAL_EXAM_DEFAULT_ROOM; + std::string zone = "SEE INSTRUCTOR"; + std::string time = GLOBAL_EXAM_TIME; + std::string row = ""; + std::string seat = ""; + if (s->getSection() == 0) { + //room = ""; + //zone = ""; + time = ""; + } + if (s->getExamRoom() == "") { + //std::cout << "NO ROOM FOR " << s->getUserName() << std::endl; + } else { + room = s->getExamRoom(); + zone = s->getExamZone(); + row = s->getExamRow(); + seat = s->getExamSeat(); + if (s->getExamTime() != "") { + time = s->getExamTime(); + } + } + if (zone == "SEE_INSTRUCTOR") { + zone = "SEE INSTRUCTOR"; + } + + +#if 1 + + ostr << "\n"; + // ostr << "
\n"; + ostr << "\n"; + + if (s->getExamZoneImage() != "") { + ostr << "\n"; + } + + + ostr << "
\n"; + ostr << "\n"; + ostr << " \n"; + ostr << " \n"; + ostr << " \n"; + ostr << " \n"; + if (row != "N/A" && row !="") { + ostr << " \n"; + } + if (seat != "N/A" && seat !="") { + ostr << " \n"; + } + ostr << "
" << GLOBAL_EXAM_TITLE << "
" << GLOBAL_EXAM_DATE << "" << time << "
Your room assignment: " << room << "
Your zone assignment: " << zone << "
Your row assignment: " << row << "
Your seat assignment: " << seat << "
\n"; + ostr << "
getExamZoneImage() + "\">
\n"; + +#else + + + ostr << "\n"; + ostr << "\n"; + ostr << "
\n"; + ostr << "\n"; + ostr << " \n"; + // ostr << " \n"; + //ostr << " \n"; + + + + + if (zone == "SEE INSTRUCTOR") { + zone = "10"; + } + + std::string foo = "http://www.cs.rpi.edu/academics/courses/fall15/csci1200/hw/10_pokemon/"; + + ostr << " \n"; + ostr << " \n"; + ostr << " \n"; + ostr << " \n"; + ostr << " \n"; + + ostr << "
" << GLOBAL_EXAM_TITLE << "
" << GLOBAL_EXAM_DATE << "" << time << "
Your room assignment: " << room << "
Your list assignment: List" << zone << ".txt
Small Input: PokedexSmall" << zone << ".txt
Small Input Obfuscate: PokedexSmallObfuscate" << zone << ".txt
Small Output Obfuscate: OutputSmallObfuscate" << zone << ".txt
Small Output Obfuscate w/ Breeding: OutputSmallObfuscateBreeding" << zone << ".txt
\n"; + ostr << "
\n"; + + + +#endif + + + std::string x1 = s->getExamZone(); + std::string x2 = s->getZone(GLOBAL_ACTIVE_TEST_ZONE); + + if (x2.size() > 0) { + assert (x1.size() > 0); + if (x1.size() > 1 || std::toupper(x1[0]) != std::toupper(x2[0]) || x2.find('?') != std::string::npos || x2.size() == 1) { + std::cout << "WRONG ZONE" << s->getUserName() << " " << x1 << " " < &students, int rank, int month, int day, int year, + enum GRADEABLE_ENUM which_gradeable_enum) { + + /* + ostr.exceptions ( std::ofstream::failbit | std::ofstream::badbit ); + try { + ostr.open(filename.c_str()); + } + catch (std::ofstream::failure e) { + std::cout << "FAILED TO OPEN " << filename << std::endl; + std::cerr << "Exception opening/reading file"; + exit(0); + } + */ +} + + +void SelectBenchmarks(std::vector &select_students, const std::vector &students, + Student *sp, Student *sa, Student *sb, Student *sc, Student *sd) { + int myrow = 1; + + int offset = select_students.size(); + select_students.resize(select_students.size()+NumVisibleBenchmarks()); + + for (unsigned int stu= 0; stu < students.size(); stu++) { + std::string default_color="ffffff"; + Student *this_student = students[stu]; + myrow++; + + int which; + + if (this_student->getLastName() == "") { + if (this_student == sp) { + which = WhichVisibleBenchmark("perfect"); + if (which >= 0) select_students[offset+which]=myrow; + } else if (this_student == AVERAGE_STUDENT_POINTER) { + which = WhichVisibleBenchmark("average"); + if (which >= 0) select_students[offset+which]=myrow; + } else if (this_student == STDDEV_STUDENT_POINTER) { + which = WhichVisibleBenchmark("stddev"); + if (which >= 0) select_students[offset+which]=myrow; + } else if (this_student == sa) { + which = WhichVisibleBenchmark("lowest_a-"); + if (which >= 0) select_students[offset+which]=myrow; + } else if (this_student == sb) { + which = WhichVisibleBenchmark("lowest_b-"); + if (which >= 0) select_students[offset+which]=myrow; + } else if (this_student == sc) { + which = WhichVisibleBenchmark("lowest_c-"); + if (which >= 0) select_students[offset+which]=myrow; + } else if (this_student == sd) { + which = WhichVisibleBenchmark("lowest_d"); + if (which >= 0) select_students[offset+which]=myrow; + } + } + } +} + + +void start_table_output( bool for_instructor, + const std::vector &students, int rank, int month, int day, int year, + Student *sp, Student *sa, Student *sb, Student *sc, Student *sd) { + + std::vector all_students; + std::vector select_students; + std::vector instructor_data; + std::vector student_data; + + Table table; + + + // ===================================================================================================== + // ===================================================================================================== + // DEFINE HEADER ROW + int counter = 0; + table.set(0,counter++,TableCell("ffffff","#")); + table.set(0,counter++,TableCell("ffffff","SECTION")); + if (DISPLAY_INSTRUCTOR_NOTES) { + table.set(0,counter++,TableCell("ffffff","part.")); + table.set(0,counter++,TableCell("ffffff","under.")); + table.set(0,counter++,TableCell("ffffff","notes")); + } + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","USERNAME")); + int last_name_counter=counter; table.set(0,counter++,TableCell("ffffff","LAST")); + + if (DISPLAY_INSTRUCTOR_NOTES || DISPLAY_FINAL_GRADE) { + table.set(0,counter++,TableCell("ffffff","FIRST (LEGAL)")); + } + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","FIRST")); + student_data.push_back(last_name_counter); + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + + if (DISPLAY_EXAM_SEATING) { + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","exam room")); + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","exam zone")); + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","exam row")); + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","exam seat")); + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","exam time")); + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + } + + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","OVERALL")); + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + + if (DISPLAY_FINAL_GRADE) { + std::cout << "DISPLAY FINAL GRADE" << std::endl; + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","FINAL GRADE")); + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + if (DISPLAY_MOSS_DETAILS) { + table.set(0,counter++,TableCell("ffffff","RAW GRADE")); + table.set(0,counter++,TableCell(grey_divider)); + } + } + + // ---------------------------- + // % OF OVERALL AVERAGE FOR EACH GRADEABLE + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + enum GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + if (g == GRADEABLE_ENUM::NOTE) { + assert (GRADEABLES[g].getPercent() < 0.01); + continue; + } + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff",gradeable_to_string(g)+" %")); + } + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + + // ---------------------------- + // DETAILS OF EACH GRADEABLE + if (DISPLAY_GRADE_DETAILS) { + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + for (int j = 0; j < GRADEABLES[g].getCount(); j++) { + if (g != GRADEABLE_ENUM::NOTE) { + student_data.push_back(counter); + } + std::string gradeable_id = GRADEABLES[g].getID(j); + std::string gradeable_name = ""; + if (GRADEABLES[g].hasCorrespondence(gradeable_id)) { + gradeable_name = GRADEABLES[g].getCorrespondence(gradeable_id).second; + //gradeable_name = spacify(gradeable_name); + } + table.set(0,counter++,TableCell("ffffff",gradeable_name)); + } + if (g != GRADEABLE_ENUM::NOTE) { + student_data.push_back(counter); + } + table.set(0,counter++,TableCell(grey_divider)); + + if (g == GRADEABLE_ENUM::TEST && TEST_IMPROVEMENT_AVERAGING_ADJUSTMENT) { + for (int j = 0; j < GRADEABLES[g].getCount(); j++) { + student_data.push_back(counter); + std::string gradeable_id = GRADEABLES[g].getID(j); + std::string gradeable_name = ""; + if (GRADEABLES[g].hasCorrespondence(gradeable_id)) { + gradeable_name = "Adjusted " + GRADEABLES[g].getCorrespondence(gradeable_id).second; + } + table.set(0,counter++,TableCell("ffffff",gradeable_name)); + } + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + } + } + + if (DISPLAY_LATE_DAYS) { + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","ALLOWED LATE DAYS")); + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","USED LATE DAYS")); + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + } + } + + + + + // ---------------------------- + // ICLICKER + if (DISPLAY_ICLICKER && ICLICKER_QUESTION_NAMES.size() > 0) { + + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","iclicker status")); + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","ICLICKER TOTAL")); + //student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff","ICLICKER RECENT")); + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + + /* + ostr << " " + << "ICLICKER QUESTIONS
CORRECT(green)=1.0, INCORRECT(red)=0.5, POLL(yellow)=1.0, NO ANSWER(white)=0.0
30.0 iClicker points = 3rd late day, 60.0 iClicker pts = 4th late day, 90.0 iClicker pts = 5th late day
≥8.0/12.0 most recent=Priority Help Queue (iClicker status highlighted in blue)"; + */ + + for (unsigned int i = 0; i < ICLICKER_QUESTION_NAMES.size(); i++) { + student_data.push_back(counter); table.set(0,counter++,TableCell("ffffff",ICLICKER_QUESTION_NAMES[i])); + } + student_data.push_back(counter); table.set(0,counter++,TableCell(grey_divider)); + + } + + // ===================================================================================================== + // ===================================================================================================== + // HORIZONTAL GRAY DIVIDER + for (int i = 0; i < table.numCols(); i++) { + table.set(1,i,TableCell(grey_divider)); + } + + + // header row + select_students.push_back(0); + select_students.push_back(1); + select_students.push_back(-1); // replace this with the real student! + select_students.push_back(1); + + + std::map student_correspondences; + + // ===================================================================================================== + // ===================================================================================================== + // ALL OF THE STUDENTS + + SelectBenchmarks(select_students,students,sp,sa,sb,sc,sd); + + + int myrank = 1; + int myrow = 1; + int last_section = -1; + for (unsigned int stu= 0; stu < students.size(); stu++) { + + Student *this_student = students[stu]; + + std::string default_color="ffffff"; + + myrow++; + counter = 0; + if (this_student->getLastName() == "") { + if (this_student == sp) { + default_color= coloritcolor(5,5,4,3,2,1); + } else if (this_student == sa) { + default_color= coloritcolor(4,5,4,3,2,1); + } else if (this_student == sb) { + default_color= coloritcolor(3,5,4,3,2,1); + } else if (this_student == sc) { + default_color= coloritcolor(2,5,4,3,2,1); + } else if (this_student == sd) { + default_color= coloritcolor(1,5,4,3,2,1); + } + assert (default_color.size()==6); + table.set(myrow,counter++,TableCell(default_color,"")); + } else { + //std::cout << " WHO? " << this_student->getUserName() << std::endl; + student_correspondences[myrow] = this_student->getUserName(); + if (GLOBAL_sort_order == "by_section" && this_student->getSection() != last_section) { + myrank=1; + last_section = this_student->getSection(); + } + if (validSection(this_student->getSection())) { + assert (default_color.size()==6); + table.set(myrow,counter++,TableCell(default_color,std::to_string(myrank))); + myrank++; + } else { + assert (default_color.size()==6); + table.set(myrow,counter++,TableCell(default_color,"")); + } + } + + + std::string section_color = default_color; + std::string section_label = ""; + colorit_section2(this_student->getSection(),section_color,section_label); + assert (section_color.size()==6); + table.set(myrow,counter++,TableCell(section_color,section_label)); + + if (DISPLAY_INSTRUCTOR_NOTES) { + float participation = this_student->getParticipation(); + std::string color = coloritcolor(participation,5,4,3,2,1); + table.set(myrow,counter++,TableCell(color,participation,1)); + float understanding = this_student->getUnderstanding(); + color = coloritcolor(understanding,5,4,3,2,1); + table.set(myrow,counter++,TableCell(color,understanding,1)); + std::string notes; + std::vector ews = this_student->getEarlyWarnings(); + for (std::size_t i = 0; i < ews.size(); i++) { + notes += ews[i]; + } + std::string other_note = this_student->getOtherNote(); + std::string recommendation = this_student->getRecommendation(); + std::string THING = + ""+notes+" " + + ""+other_note+" " + + ""+recommendation+""; + assert (default_color.size()==6); + table.set(myrow,counter++,TableCell(default_color,THING)); + } + + //counter+=3; + assert (default_color.size()==6); + table.set(myrow,counter++,TableCell(default_color,this_student->getUserName())); + table.set(myrow,counter++,TableCell(default_color,this_student->getLastName())); + if (DISPLAY_INSTRUCTOR_NOTES || DISPLAY_FINAL_GRADE) { + table.set(myrow,counter++,TableCell(default_color,this_student->getFirstName())); + } + table.set(myrow,counter++,TableCell(default_color,this_student->getPreferredName())); + table.set(myrow,counter++,TableCell(grey_divider)); + + + if (DISPLAY_EXAM_SEATING) { + + std::string room = GLOBAL_EXAM_DEFAULT_ROOM; + std::string zone = "SEE INSTRUCTOR"; + std::string row = ""; + std::string seat = ""; + std::string time = GLOBAL_EXAM_TIME; + + if (this_student->getSection() == 0) { //LastName() == "") { + room = ""; + zone = ""; + time = ""; + } + if (this_student->getExamRoom() == "") { + //std::cout << "NO ROOM FOR " << this_student->getUserName() << std::endl; + } else { + room = this_student->getExamRoom(); + zone = this_student->getExamZone(); + row = this_student->getExamRow(); + seat = this_student->getExamSeat(); + if (this_student->getExamTime() != "") { + time = this_student->getExamTime(); + } + } + if (zone == "SEE_INSTRUCTOR") { + zone = "SEE INSTRUCTOR"; + } + + table.set(myrow,counter++,TableCell("ffffff",room)); + table.set(myrow,counter++,TableCell("ffffff",zone)); + table.set(myrow,counter++,TableCell("ffffff",row)); + table.set(myrow,counter++,TableCell("ffffff",seat)); + table.set(myrow,counter++,TableCell("ffffff",time)); + table.set(myrow,counter++,TableCell(grey_divider)); + } + + + float grade; + if (this_student->getUserName() == "AVERAGE" || + this_student->getUserName() == "STDDEV") { + // Special case for overall average and standard deviation. + // Mathematically, we can't simply add the std dev for the + // different gradeables. Note also: the average isn't a simple + // addition either, since blank scores for a specific gradeable + // are omitted from the average. + std::vector vals; + for (unsigned int S = 0; S < students.size(); S++) { + if (validSection(students[S]->getSection())) { + vals.push_back(students[S]->overall()); + } + } + float tmp_average = compute_average(vals); + if (this_student->getUserName() == "AVERAGE") { + grade = tmp_average; + } else { + float tmp_std_dev = compute_stddev(vals,tmp_average); + grade = tmp_std_dev; + } + } else { + grade = this_student->overall(); + } + + std::string color = coloritcolor(grade, + sp->overall(), + sa->overall(), + sb->overall(), + sc->overall(), + sd->overall()); + if (this_student == STDDEV_STUDENT_POINTER) color="ffffff"; + assert (color.size()==6); + table.set(myrow,counter++,TableCell(color,grade,2)); + table.set(myrow,counter++,TableCell(grey_divider)); + + + if (DISPLAY_FINAL_GRADE) { + std::string g = this_student->grade(false,sd); + color = GradeColor(g); + if (this_student->getMossPenalty() < -0.01) { + g += "@"; + } + assert (color.size()==6); + table.set(myrow,counter++,TableCell(color,g,"",0,CELL_CONTENTS_VISIBLE,"center")); + table.set(myrow,counter++,TableCell(grey_divider)); + + if (DISPLAY_MOSS_DETAILS) { + std::string g2 = this_student->grade(true,sd); + color = GradeColor(g2); + table.set(myrow,counter++,TableCell(color,g2,"",0,CELL_CONTENTS_VISIBLE,"center")); + table.set(myrow,counter++,TableCell(grey_divider)); + } + } + + // ---------------------------- + // % OF OVERALL AVERAGE FOR EACH GRADEABLE + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + enum GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + if (g == GRADEABLE_ENUM::NOTE) { + assert (GRADEABLES[g].getPercent() < 0.01); + continue; + } + + float grade; + if (this_student->getUserName() == "AVERAGE" || + this_student->getUserName() == "STDDEV") { + // Special case for per gradeable average and standard deviation. + // Mathematically, we can't simply add the std dev for the + // different gradeables. Note also: the average isn't a simple + // addition either, since blank scores for a specific gradeable + // are omitted from the average. + std::vector vals; + for (unsigned int S = 0; S < students.size(); S++) { + if (validSection(students[S]->getSection())) { + vals.push_back(students[S]->GradeablePercent(g)); + } + } + float tmp_average = compute_average(vals); + if (this_student->getUserName() == "AVERAGE") { + grade = tmp_average; + } else { + float tmp_std_dev = compute_stddev(vals,tmp_average); + grade = tmp_std_dev; + } + } else { + grade = this_student->GradeablePercent(g); + } + + std::string color = coloritcolor(grade, + sp->GradeablePercent(g), + sa->GradeablePercent(g), + sb->GradeablePercent(g), + sc->GradeablePercent(g), + sd->GradeablePercent(g)); + if (this_student == STDDEV_STUDENT_POINTER) color="ffffff"; + assert (color.size()==6); + table.set(myrow,counter++,TableCell(color,grade,2)); + } + table.set(myrow,counter++,TableCell(grey_divider)); + + // ---------------------------- + // DETAILS OF EACH GRADEABLE + if (DISPLAY_GRADE_DETAILS) { + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + enum CELL_CONTENTS_STATUS visible = CELL_CONTENTS_VISIBLE; + if (g == GRADEABLE_ENUM::TEST) { + visible = CELL_CONTENTS_NO_DETAILS; + } + for (int j = 0; j < GRADEABLES[g].getCount(); j++) { + float grade = this_student->getGradeableItemGrade(g,j).getValue(); + std::string color = coloritcolor(grade, + sp->getGradeableItemGrade(g,j).getValue(), + sa->getGradeableItemGrade(g,j).getValue(), + sb->getGradeableItemGrade(g,j).getValue(), + sc->getGradeableItemGrade(g,j).getValue(), + sd->getGradeableItemGrade(g,j).getValue()); + if (this_student == STDDEV_STUDENT_POINTER) color="ffffff"; + std::string details; + details = this_student->getGradeableItemGrade(g,j).getNote(); + std::string status = this_student->getGradeableItemGrade(g,j).getStatus(); + + if (status.find("Bad") != std::string::npos) { + details += " " + status; + } + int late_days_used = this_student->getGradeableItemGrade(g,j).getLateDaysUsed(); + assert (color.size()==6); + table.set(myrow,counter++,TableCell(color,grade,1,details,late_days_used,visible)); + } + table.set(myrow,counter++,TableCell(grey_divider)); + + // FIXME + if (g == GRADEABLE_ENUM::TEST && TEST_IMPROVEMENT_AVERAGING_ADJUSTMENT) { + for (int j = 0; j < GRADEABLES[g].getCount(); j++) { + float grade = this_student->adjusted_test(j); + std::string color = coloritcolor(this_student->adjusted_test(j), + sp->adjusted_test(j), + sa->adjusted_test(j), + sb->adjusted_test(j), + sc->adjusted_test(j), + sd->adjusted_test(j)); + if (this_student == STDDEV_STUDENT_POINTER) color="ffffff"; + assert (color.size()==6); + table.set(myrow,counter++,TableCell(color,grade,1,"",0,visible)); + } + table.set(myrow,counter++,TableCell(grey_divider)); + } + } + + if (DISPLAY_LATE_DAYS) { + // LATE DAYS + if (this_student->getLastName() != "") { + int allowed = this_student->getAllowedLateDays(100); + std::string color = coloritcolor(allowed,5,4,3,2,2); + table.set(myrow,counter++,TableCell(color,allowed,"",0,CELL_CONTENTS_VISIBLE,"right")); + int used = this_student->getUsedLateDays(); + color = coloritcolor(allowed-used+2, 5+2, 3+2, 2+2, 1+2, 0+2); + table.set(myrow,counter++,TableCell(color,used,"",0,CELL_CONTENTS_VISIBLE,"right")); + } else { + color="ffffff"; // default_color; + table.set(myrow,counter++,TableCell(color,"")); + table.set(myrow,counter++,TableCell(color,"")); + } + table.set(myrow,counter++,TableCell(grey_divider)); + } + } + + + + // ---------------------------- + // ICLICKER + if (DISPLAY_ICLICKER && ICLICKER_QUESTION_NAMES.size() > 0) { + + if (this_student->getRemoteID().size() != 0) { // && this_student->hasPriorityHelpStatus()) { + table.set(myrow,counter++,TableCell("ccccff","registered")); + //} else if (this_student->getRemoteID() != "") { + //table.set(myrow,counter++,TableCell("ffffff","registered")); + } else if (this_student->getLastName() == "") { + table.set(myrow,counter++,TableCell("ffffff"/*default_color*/,"")); + } else { + table.set(myrow,counter++,TableCell("ffcccc","no iclicker registration")); + } + table.set(myrow,counter++,TableCell(grey_divider)); + + if (this_student->getLastName() != "" || + this_student->getUserName() == "PERFECT") { + float grade = this_student->getIClickerTotalFromStart(); + std::string color = coloritcolor(grade, + MAX_ICLICKER_TOTAL, + 0.90*MAX_ICLICKER_TOTAL, + 0.80*MAX_ICLICKER_TOTAL, + 0.60*MAX_ICLICKER_TOTAL, + 0.40*MAX_ICLICKER_TOTAL); + table.set(myrow,counter++,TableCell(color,grade,1)); + /* + grade = this_student->getIClickerRecent(); + color = coloritcolor(grade, + ICLICKER_RECENT, + 0.90*ICLICKER_RECENT, + 0.80*ICLICKER_RECENT, + 0.60*ICLICKER_RECENT, + 0.40*ICLICKER_RECENT); + table.set(myrow,counter++,TableCell(color,grade,1)); + */ + } else { + color="ffffff"; // default_color; + table.set(myrow,counter++,TableCell(color,"")); + //table.set(myrow,counter++,TableCell(color,"")); + } + + table.set(myrow,counter++,TableCell(grey_divider)); + for (unsigned int i = 0; i < ICLICKER_QUESTION_NAMES.size(); i++) { + std::pair answer = this_student->getIClickerAnswer(ICLICKER_QUESTION_NAMES[i]); + std::string thing = answer.first; + std::string color = "ffffff"; //default_color; + if (answer.second == ICLICKER_CORRECT) { + color = "aaffaa"; + } else if (answer.second == ICLICKER_PARTICIPATED) { + color = "ffffaa"; + } else if (answer.second == ICLICKER_INCORRECT) { + color = "ffaaaa"; + } else { + assert (answer.second == ICLICKER_NOANSWER); + } + table.set(myrow,counter++,TableCell(color,thing,"",0,CELL_CONTENTS_VISIBLE_INSTRUCTOR,"center")); + } + table.set(myrow,counter++,TableCell(grey_divider)); + } + } + + + + for (int i = 0; i < table.numCols(); i++) { + instructor_data.push_back(i); + } + // need to add 2, for the perfect & average student. + for (unsigned int i = 0; i < students.size()+2; i++) { + all_students.push_back(i); + } + + std::cout << "WRITE ALL.html" << std::endl; + std::ofstream ostr2(OUTPUT_FILE); + + GLOBAL_instructor_output = true; + table.output(ostr2, all_students,instructor_data); + + end_table(ostr2,true,NULL); + ostr2.close(); + + std::stringstream ss; + ss << ALL_STUDENTS_OUTPUT_DIRECTORY << "output_" << month << "_" << day << "_" << year << ".html"; + + std::string command = "cp -f output.html " + ss.str(); + std::cout << "RUN COMMAND " << command << std::endl; + system(command.c_str()); + + + for (std::map::iterator itr = student_correspondences.begin(); + itr != student_correspondences.end(); itr++) { + + select_students[2] = itr->first; + std::string filename = "individual_summary_html/" + itr->second + "_summary.html"; + std::ofstream ostr3(filename.c_str()); + assert (ostr3.good()); + + Student *s = GetStudent(students,itr->second); + std::string last_update; + if (s != NULL) { + last_update = s->getLastUpdate(); + } + GLOBAL_instructor_output = false; + + table.output(ostr3, select_students,student_data,true,true,last_update); + + end_table(ostr3,false,s); + } + + Student* s = NULL; + if (rank != -1) { + s = students[rank]; + assert (s != NULL); + } +} + + + + +void end_table(std::ofstream &ostr, bool for_instructor, Student *s) { + + + ostr << "

* = 1 late day used

" << std::endl; + + if (GLOBAL_instructor_output == false && + DISPLAY_ICLICKER) { + + ostr << "

IClicker Legend:
   CORRECT(green)=1.0
   INCORRECT(red)=0.5
   POLL(yellow)=1.0
   NO ANSWER(white)=0.0
" << std::endl; + if (s != NULL) { + ostr << "Initial number of allowed late days: " << s->getDefaultAllowedLateDays() << "
" << std::endl; + } + if(!GLOBAL_earned_late_days.empty()) { + ostr << "Extra late days earned after iclicker points: "; + for (std::size_t i = 0; i < GLOBAL_earned_late_days.size(); i++) { + ostr << GLOBAL_earned_late_days[i]; + if (i < GLOBAL_earned_late_days.size() - 1) { + ostr << ", "; + } + } + ostr << "
" << std::endl; + } + ostr << "

" << std::endl; + + + //ostr << GLOBAL_earned_late + + //25.0 iClicker points = 3rd late day, 50.0 iClicker pts = 4th late day, 75.0 iClicker pts = 5th late day
≥8.0/12.0 most recent=Priority Help Queue (iClicker status highlighted in blue)"; + } + + ostr << "

 

\n"; + + + + bool print_moss_message = false; + if (s != NULL && s->getMossPenalty() < -0.01) { + print_moss_message = true; + } + + if (print_moss_message) { + ostr << "@ = final grade with Academic Integrity Violation penalty

 

\n"; + } + + if (DISPLAY_FINAL_GRADE) { // && students.size() > 50) { + + int total_A = grade_counts[Grade("A")] + grade_counts[Grade("A-")]; + int total_B = grade_counts[Grade("B+")] + grade_counts[Grade("B")] + grade_counts[Grade("B-")]; + int total_C = grade_counts[Grade("C+")] + grade_counts[Grade("C")] + grade_counts[Grade("C-")]; + int total_D = grade_counts[Grade("D+")] + grade_counts[Grade("D")]; + int total_passed = total_A + total_B + total_C + total_D; + int total_F = grade_counts[Grade("F")]; + int total_blank = grade_counts[Grade("")]; + assert (total_blank == 0); + int total = total_passed + total_F + auditors + total_blank + dropped; + + ostr << "

\n"; + + + + ostr << "\n"; + // ostr << "
\n"; + ostr << "\n"; + ostr << ""; + ostr << ""; + ostr << ""; + ostr << ""; + ostr << "\n"; + if (for_instructor) { + ostr << "\n"; + // ostr << "\n"; + ostr << "\n"; + ostr << "\n"; + ostr << "\n"; + ostr << "\n"; + ostr << "\n"; + } + ostr << "\n"; + + ostr << "\n"; + ostr << ""; + ostr << "\n"; + ostr << "\n"; + + + + ostr << "\n"; + ostr << ""; + ostr << "\n"; + } + + if (for_instructor) { + ostr << "\n"; + ostr << "\n"; + ostr << "\n"; + ostr << "\n"; + ostr << "\n"; + } + ostr << "\n"; + + + + ostr << "
FINAL GRADEAA-B+BB-C+CC-D+DFdroppedaudittook finaltotal passeddroppedtotal
# of students"<"<"; + ostr << ""<"<"<"; + ostr << ""<"<"<"; + ostr << ""<"<\n"; + + if (for_instructor) { + ostr << ""<\n"; + //ostr << "" << grade_counts[Grade("")]<<""<\n"; + ostr << ""<\n"; + ostr << ""<\n"; + ostr << ""<\n"; + ostr << ""<\n"; + } + ostr << "
average OVERALL
of students with
this FINAL GRADE		"<"<"; + ostr << ""<"<"<"; + ostr << ""<"<"<"; + + if (for_instructor) { + ostr << ""<"<\n"; + } else { + ostr << "     "<\n"; + //ostr << ""<\n"; + ostr << "     

\n"; + + } + + ostr.close(); +} diff --git a/parsexml.py b/parsexml.py new file mode 100644 index 0000000..f983fe9 --- /dev/null +++ b/parsexml.py @@ -0,0 +1,147 @@ +#!/usr/bin/env python3 +import csv +import xml.etree.ElementTree as ET +import sys +import os.path + + +class QuestionData: + final_answer = "" + final_answer_time = 0 + first_answer = "" + attempts = 0 + first_answer_time = 0 + + def __init__(self,final_answer,final_answer_time,attempts,first_answer,first_answer_time): + self.final_answer = final_answer + self.final_answer_time = final_answer_time + self.first_answer = first_answer + self.first_answer_time = first_answer_time + self.attempts = attempts + + +def xml_to_csv(xml_filename): + """ + Parses .xml files generated by newer versions of iClicker software in SessionData + A CSV file will be written to the same path as the XML file, so it is important that any path, be it + absolute or relative, is included in the xml_filename argument. The CSV file is not a perfect replica of + older (i.e. iClicker 6) CSV files, but is our best approximation at this time. It should be enough for + Rainbow Grades to function properly. + """ + + csv_filename = xml_filename[:-3] + "csv" + try: + with open(xml_filename,"r") as readfile: + tree = ET.parse(xml_filename) + root = tree.getroot() + + questions_in_order = [] + start_times = {} + stop_times = {} + user_question_data = {} + + for child in root: + if child.tag == "p": # This is a polling tag + question = child.attrib["qn"] + start_times[question] = child.attrib["strt"] + stop_times[question] = child.attrib["stp"] + questions_in_order.append(question) + question_votes = {} + for qchild in child: + if qchild.tag == "v": # This is a voting tag + clicker_id = qchild.attrib["id"] + if clicker_id not in user_question_data: + user_question_data[clicker_id] = {} + user_question_data[clicker_id][question] = {} + if "fans" in qchild.attrib: + user_question_data[clicker_id][question] = QuestionData(qchild.attrib["ans"], + qchild.attrib["fanst"], + qchild.attrib["att"], + qchild.attrib["fans"], + qchild.attrib["tm"]) + + question_votes[clicker_id] = qchild.attrib["ans"] + + with open(csv_filename, 'w') as writefile: + csvwriter = csv.writer(writefile) # Need to change dialect to be iclicker compliant + + # Write the header + # Right now we don't have min reply/min correct in XML land, instead we have MinPart_S + next_row = ["Scoring"] + if "perf" in root.attrib: + performance = root.attrib["perf"] + else: + performance = -1 + + if "part" in root.attrib: + participation = root.attrib["part"] + else: + participation = 1 + csvwriter.writerow(["Scoring", "Performance = " + performance, + "Participation = " + participation, "Min Reply = 2", + "Min Correct = 0", + " "]) + next_row = ["Question", " ", " "] + for i in range(len(questions_in_order)): + next_row = next_row + ["Question " + str(i + 1), "Score", "Final Answer Time", "Number of Attempts", + "First Response", "Time"] + csvwriter.writerow(next_row) + next_row = ["Start Time", " ", " "] + for question in questions_in_order: + next_row = next_row + [" " + start_times[question], " ", " ", " ", " ", " "] + csvwriter.writerow(next_row) + + next_row = ["Stop Time", " ", " "] + first_stop = True + for question in questions_in_order: + if not first_stop: + next_row = next_row + [" " + stop_times[question], " ", " ", " ", " ", " "] + else: + next_row = next_row + [stop_times[question], " ", " ", " ", " ", " "] + first_stop = False + csvwriter.writerow(next_row) + + next_row = ["Correct Answer", " ", " "] + first_stop = True + for question in questions_in_order: + if not first_stop: + next_row = next_row + [" ", " ", " ", " ", " ", " "] + else: + next_row = next_row + ["", " ", " ", " ", " ", " "] + first_stop = False + csvwriter.writerow(next_row) + + for user in sorted(user_question_data.keys()): + next_row = [user, "", "0"] + for question in questions_in_order: + if question in user_question_data[user]: + qd = user_question_data[user][question] + next_row = next_row + [qd.final_answer, 0, qd.final_answer_time, qd.attempts, + qd.first_answer, qd.first_answer_time] + else: + next_row = next_row + ["", "", "", "", "", ""] + csvwriter.writerow(next_row) + + except IOError as e: + print("File I/O error: {}".format(e)) + exit(-1) + + +if __name__ == '__main__': + if len(sys.argv) != 2: + print("Correct usage is {} [file with iclicker {\"file\":...} entries]".format(sys.argv[0])) + exit(-1) + + files = [] + + try: + with open(sys.argv[1]) as json_file: + for line in json_file: + # Extract just the filenames of the session data + files += [x.strip()[1:-1] for x in line.split("[")[1].split("]")[0].split(",")] + except IOError as e: + print("Error reading JSON excerpt: {}".format(e)) + + for filename in files: + if len(filename) >= 4 and filename[-4:] == ".xml": + xml_to_csv(filename) diff --git a/student.cpp b/student.cpp new file mode 100644 index 0000000..4d6326f --- /dev/null +++ b/student.cpp @@ -0,0 +1,485 @@ +#include "student.h" + +const std::string GradeColor(const std::string &grade); + +// ============================================================================================= +// ============================================================================================= +// CONSTRUCTOR + +Student::Student() { + + // personal data + // (defaults to empty string) + lefty = false; + + // registration status + section = 0; + audit = false; + withdraw = false; + independentstudy = false; + + default_allowed_late_days = 0; + current_allowed_late_days = 0; + + // grade data + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + all_item_grades[g] = std::vector(GRADEABLES[g].getCount(),ItemGrade(0)); + } + // (iclicker defaults to empty map) + + zones = std::vector(GRADEABLES[GRADEABLE_ENUM::TEST].getCount(),""); + moss_penalty = 0; + cached_hw = -1; + + // other grade-like data + // (remote id defaults to empty vector) + academic_integrity_form = false; + participation = 0; + understanding = 0; + + // info about exam assignments + // (defaults to empty string) + + // per student notes + // (defaults to empty string) +} + + + + +// lookup a student by username +Student* GetStudent(const std::vector &students, const std::string& username) { + for (unsigned int i = 0; i < students.size(); i++) { + if (students[i]->getUserName() == username) return students[i]; + } + return NULL; +} + + + + + +// ============================================================================================= +// ============================================================================================= +// accessor & modifier for grade data + +const ItemGrade& Student::getGradeableItemGrade(GRADEABLE_ENUM g, int i) const { + static ItemGrade emptyItemGrade(0); + //std::cout << "i " << i << " count " << GRADEABLES[g].getCount() << std::endl; + if (i >= GRADEABLES[g].getCount()) { + return emptyItemGrade; + } + assert (i >= 0 && i < GRADEABLES[g].getCount()); + std::map >::const_iterator itr = all_item_grades.find(g); + assert (itr != all_item_grades.end()); + assert (int(itr->second.size()) > i); + + return itr->second[i]; //return value; +} + + + +void Student::setGradeableItemGrade(GRADEABLE_ENUM g, int i, float value, + int late_days_used, const std::string ¬e, const std::string &status) { + assert (i >= 0 && i < GRADEABLES[g].getCount()); + std::map >::iterator itr = all_item_grades.find(g); + assert (itr != all_item_grades.end()); + assert (int(itr->second.size()) > i); + itr->second[i] = ItemGrade(value,late_days_used,note,status); +} + + + +// ============================================================================================= +// GRADER CALCULATION HELPER FUNCTIONS + +class score_object { +public: + score_object(float s,float m,float p,float sm):score(s),max(m),percentage(p),scale_max(sm){} + float score; + float max; + float percentage; + float scale_max; +}; + +bool operator<(const score_object &a, const score_object &b) { + return a.score < b.score; +} + +float Student::GradeablePercent(GRADEABLE_ENUM g) const { + if (GRADEABLES[g].getCount() == 0) return 0; + //if (GRADEABLES[g].getMaximum() == 0) return 0; + //assert (GRADEABLES[g].getMaximum() > 0); + assert (GRADEABLES[g].getPercent() >= 0); + + // special rules for tests + if (g == GRADEABLE_ENUM::TEST && TEST_IMPROVEMENT_AVERAGING_ADJUSTMENT) { + return adjusted_test_pct(); + } + + // normalize & drop lowest # + if (g == GRADEABLE_ENUM::QUIZ && QUIZ_NORMALIZE_AND_DROP > 0) { + return quiz_normalize_and_drop(QUIZ_NORMALIZE_AND_DROP); + } + + if (g == GRADEABLE_ENUM::TEST && LOWEST_TEST_COUNTS_HALF) { + return lowest_test_counts_half_pct(); + } + + // collect the scores in a vector + std::vector scores; + for (int i = 0; i < GRADEABLES[g].getCount(); i++) { + float s = getGradeableItemGrade(g,i).getValue(); + std::string id = GRADEABLES[g].getID(i); + float m = GRADEABLES[g].getItemMaximum(id); + float p = GRADEABLES[g].getItemPercentage(id); + float sm = GRADEABLES[g].getScaleMaximum(id); + scores.push_back(score_object(s,m,p,sm)); + } + + // sort the scores (smallest first) + std::sort(scores.begin(),scores.end()); + + assert (GRADEABLES[g].getRemoveLowest() >= 0 && + GRADEABLES[g].getRemoveLowest() < GRADEABLES[g].getCount()); + + // sum the remaining (higher) scores + float sum_max = 0; + for (int i = GRADEABLES[g].getRemoveLowest(); i < GRADEABLES[g].getCount(); i++) { + float m = scores[i].max; + sum_max += m; + } + + // sum the remaining (higher) scores + float sum = 0; + for (int i = GRADEABLES[g].getRemoveLowest(); i < GRADEABLES[g].getCount(); i++) { + float s = scores[i].score; + float m = scores[i].max; + float p = scores[i].percentage; + float sm = scores[i].scale_max; + float my_max = std::max(m,sm); + if (p < 0) { + assert (my_max > 0); + if (sum_max > 0) { + p = std::max(m,sm) / sum_max; + } else { + // pure extra credit category + p = std::max(m,sm) / my_max; + } + } + sum += p * s / my_max; + } + + return 100*GRADEABLES[g].getPercent()*sum; +} + + + + +float Student::adjusted_test(int i) const { + assert (i >= 0 && i < GRADEABLES[GRADEABLE_ENUM::TEST].getCount()); + float a = getGradeableItemGrade(GRADEABLE_ENUM::TEST,i).getValue(); + float b; + if (i+1 < GRADEABLES[GRADEABLE_ENUM::TEST].getCount()) { + b = getGradeableItemGrade(GRADEABLE_ENUM::TEST,i+1).getValue(); + } else { + assert (GRADEABLES[GRADEABLE_ENUM::EXAM].getCount() == 1); + b = getGradeableItemGrade(GRADEABLE_ENUM::EXAM,0).getValue(); + // HACK need to scale the final exam! + b *= 0.6667; + } + + if (a > b) return a; + return (a+b) * 0.5; +} + + +float Student::adjusted_test_pct() const { + float sum = 0; + for (int i = 0; i < GRADEABLES[GRADEABLE_ENUM::TEST].getCount(); i++) { + sum += adjusted_test(i); + } + float answer = 100 * GRADEABLES[GRADEABLE_ENUM::TEST].getPercent() * sum / float (GRADEABLES[GRADEABLE_ENUM::TEST].getMaximum()); + return answer; +} + + + +float Student::quiz_normalize_and_drop(int num) const { + + assert (num > 0); + + // collect the normalized quiz scores in a vector + std::vector scores; + for (int i = 0; i < GRADEABLES[GRADEABLE_ENUM::QUIZ].getCount(); i++) { + // the max for this quiz + float p = PERFECT_STUDENT_POINTER->getGradeableItemGrade(GRADEABLE_ENUM::QUIZ,i).getValue(); + // this students score + float v = getGradeableItemGrade(GRADEABLE_ENUM::QUIZ,i).getValue(); + scores.push_back(v/p); + } + + assert (scores.size() > std::size_t(num)); //Relies on the assert(num > 0) at the top of this function. + + // sort the scores + sort(scores.begin(),scores.end()); + + // sum up all but the lowest "num" scores + float sum = 0; + for (std::size_t i = num; i < scores.size(); i++) { + sum += scores[i]; + } + + // the overall percent of the final grade for quizzes + return 100 * GRADEABLES[GRADEABLE_ENUM::QUIZ].getPercent() * sum / float (scores.size()-num); +} + + +float Student::lowest_test_counts_half_pct() const { + + int num_tests = GRADEABLES[GRADEABLE_ENUM::TEST].getCount(); + assert (num_tests > 0); + + // first, collect & sort the scores + std::vector scores; + for (int i = 0; i < num_tests; i++) { + scores.push_back(getGradeableItemGrade(GRADEABLE_ENUM::TEST,i).getValue()); + } + std::sort(scores.begin(),scores.end()); + + // then sum the scores + float sum = 0.5 * scores[0]; + float weight_total = 0.5; + for (int i = 1; i < num_tests; i++) { + sum += scores[i]; + weight_total += 1.0; + } + + // renormalize! + sum *= float(num_tests) / weight_total; + + // scale to percent; + return 100 * GRADEABLES[GRADEABLE_ENUM::TEST].getPercent() * sum / float (GRADEABLES[GRADEABLE_ENUM::TEST].getMaximum()); +} + + +// ============================================================================================= +// ============================================================================================= + +int Student::getAllowedLateDays(int which_lecture) const { + if (getSection() == 0) return 0; + + //int answer = 2; + + int answer = default_allowed_late_days; + + // average 4 questions per lecture 2-28 ~= 112 clicker questions + // 30 questions => 3 late days + // 60 questions => 4 late days + // 90 qustions => 5 late days + + float total = getIClickerTotal(which_lecture,0); + + for (unsigned int i = 0; i < GLOBAL_earned_late_days.size(); i++) { + if (total >= GLOBAL_earned_late_days[i]) { + answer++; + } + } + + for (unsigned int i = 0; i < bonus_late_days_which_lecture.size(); i++) { + if (bonus_late_days_which_lecture[i] <= which_lecture) { + answer++; + } + } + + return std::max(current_allowed_late_days,answer); + +} + +// get the total used late days +int Student::getUsedLateDays() const { + int answer = 0; + for (std::map >::const_iterator itr = all_item_grades.begin(); itr != all_item_grades.end(); itr++) { + for (std::size_t i = 0; i < itr->second.size(); i++) { + answer += itr->second[i].getLateDaysUsed(); + } + } + return answer; +} + +// ============================================================================================= + +float Student::overall_b4_moss() const { + float answer = 0; + for (unsigned int i = 0; i < ALL_GRADEABLES.size(); i++) { + GRADEABLE_ENUM g = ALL_GRADEABLES[i]; + answer += GradeablePercent(g); + } + return answer; +} + +std::string Student::grade(bool flag_b4_moss, Student *lowest_d) const { + + if (section == 0) return ""; + + if (!flag_b4_moss && manual_grade != "") return manual_grade; + + float over = overall(); + if (flag_b4_moss) { + over = overall_b4_moss(); + } + + + // some criteria that might indicate automatica failure of course + // (instructor can override with manual grade) + int failed_lab = (GradeablePercent(GRADEABLE_ENUM::LAB) < 1.01 * lowest_d->GradeablePercent(GRADEABLE_ENUM::LAB) ) ? true : false; + int failed_hw = (GradeablePercent(GRADEABLE_ENUM::HOMEWORK) < 0.95 * lowest_d->GradeablePercent(GRADEABLE_ENUM::HOMEWORK) ) ? true : false; + int failed_testA = (GradeablePercent(GRADEABLE_ENUM::TEST) < 0.90 * lowest_d->GradeablePercent(GRADEABLE_ENUM::TEST) ) ? true : false; + int failed_testB = (GradeablePercent(GRADEABLE_ENUM::EXAM) < 0.90 * lowest_d->GradeablePercent(GRADEABLE_ENUM::EXAM) ) ? true : false; + int failed_testC = (GradeablePercent(GRADEABLE_ENUM::TEST) + GradeablePercent(GRADEABLE_ENUM::EXAM) < + 0.90 * lowest_d->GradeablePercent(GRADEABLE_ENUM::TEST) + lowest_d->GradeablePercent(GRADEABLE_ENUM::EXAM) ) ? true : false; + if (failed_lab || failed_hw || + ( failed_testA + + failed_testB + + failed_testC ) > 1) { + //std::cout << "SHOULD AUTO FAIL"; + + //((Student*)this)->other_note += "SHOULD AUTO FAIL"; + return "F"; + } + + + // otherwise apply the cutoffs + if (over >= CUTOFFS["A"]) return "A"; + if (over >= CUTOFFS["A-"]) return "A-"; + if (over >= CUTOFFS["B+"]) return "B+"; + if (over >= CUTOFFS["B"]) return "B"; + if (over >= CUTOFFS["B-"]) return "B-"; + if (over >= CUTOFFS["C+"]) return "C+"; + if (over >= CUTOFFS["C"]) return "C"; + if (over >= CUTOFFS["C-"]) return "C-"; + if (over >= CUTOFFS["D+"]) return "D+"; + if (over >= CUTOFFS["D"]) return "D"; + else return "F"; + + return "?"; +} + + + +void Student::mossify(const std::string &gradeable, float penalty) { + + // if the penalty is "a whole or partial letter grade".... + float average_letter_grade = (CUTOFFS["A"]-CUTOFFS["B"] + + CUTOFFS["B"]-CUTOFFS["C"] + + CUTOFFS["C"]-CUTOFFS["D"]) / 3.0; + + assert (GRADEABLES[GRADEABLE_ENUM::HOMEWORK].hasCorrespondence(gradeable)); + int which = GRADEABLES[GRADEABLE_ENUM::HOMEWORK].getCorrespondence(gradeable).first; + + if (!(getGradeableItemGrade(GRADEABLE_ENUM::HOMEWORK,which).getValue() > 0)) { + std::cerr << "WARNING: the grade for this homework is already 0, moss penalty error?" << std::endl; + } + setGradeableItemGrade(GRADEABLE_ENUM::HOMEWORK,which,0); + + // the penalty is positive + // but it will be multiplied by a negative and added to the total; + assert (penalty >= 0); + + moss_penalty += -0.0000001; + moss_penalty += -average_letter_grade * penalty; + + addWarning("[MOSS PENALTY " + std::to_string(penalty) + "]"); +} + + + +void Student::ManualGrade(const std::string &grade, const std::string &message) { + assert (grade == "A" || + grade == "A-" || + grade == "B+" || + grade == "B" || + grade == "B-" || + grade == "C+" || + grade == "C" || + grade == "C-" || + grade == "D+" || + grade == "D" || + grade == "F"); + manual_grade = grade; + other_note += "awarding a " + grade + " because " + message; +} + + +void Student::outputgrade(std::ostream &ostr,bool flag_b4_moss,Student *lowest_d) const { + std::string g = grade(flag_b4_moss,lowest_d); + + std::string color = GradeColor(g); + if (moss_penalty < -0.01) { + ostr << "" << g << " @"; + } else { + ostr << "" << g << ""; + } +} + + +// ============================================================================================= + +// zones for exams... +//const std::string& Student::getZone(int i) const { +std::string Student::getZone(int i) const { + assert (i >= 0 && i < GRADEABLES[GRADEABLE_ENUM::TEST].getCount()); return zones[i]; +} + + + +// ============================================================================================= + + +bool iclickertotalhelper(const std::string &clickername,int which_lecture) { + std::stringstream ss(clickername); + int foo; + ss >> foo; + if (foo <= which_lecture) return true; + return false; +} + + +void Student::addIClickerAnswer(const std::string& which_question, char which_answer, iclicker_answer_enum grade) { + iclickeranswers[which_question] = std::make_pair(which_answer,grade); } + +float Student::getIClickerRecent() const { + if (getUserName() == "PERFECT") { return std::min((int)ICLICKER_QUESTION_NAMES.size(),ICLICKER_RECENT); } + return getIClickerTotal(100, std::max(0,(int)ICLICKER_QUESTION_NAMES.size()-ICLICKER_RECENT)); +} + +float Student::getIClickerTotal(int which_lecture, int start) const { + if (getUserName() == "PERFECT") { return MAX_ICLICKER_TOTAL; } + float ans = 0; + for (unsigned int i = start; i < ICLICKER_QUESTION_NAMES.size(); i++) { + std::map >::const_iterator itr = iclickeranswers.find(ICLICKER_QUESTION_NAMES[i]); + if (itr == iclickeranswers.end()) continue; + if (!iclickertotalhelper(itr->first,which_lecture)) continue; + if (itr->second.second == ICLICKER_CORRECT || + itr->second.second == ICLICKER_PARTICIPATED) { + ans += 1.0; + } else if (itr->second.second == ICLICKER_INCORRECT) { + ans += 0.5; + } + } + return ans; +} + +std::pair Student::getIClickerAnswer(const std::string& which_question) const { + std::pair noanswer = std::make_pair("",ICLICKER_NOANSWER); + std::map >::const_iterator itr = iclickeranswers.find(which_question); + if (itr == iclickeranswers.end()) return noanswer; + + char x = itr->second.first; + std::string tmp(1,x); + iclicker_answer_enum val = itr->second.second; + return std::make_pair(tmp,val); +} + +// ============================================================================================= diff --git a/student.h b/student.h new file mode 100644 index 0000000..584dd2c --- /dev/null +++ b/student.h @@ -0,0 +1,249 @@ + +#ifndef _STUDENT_H_ +#define _STUDENT_H_ + +#include +#include +#include +#include +#include +#include +#include + +#include "iclicker.h" +#include "gradeable.h" +#include "constants_and_globals.h" + +//==================================================================== +//==================================================================== +// stores the grade for a single gradeable + +class ItemGrade { +public: + ItemGrade(float v, int ldu=0, const std::string& n="", const std::string &s="") { + value = v; + late_days_used = ldu; + note = n; + if (s != "UNKONWN") { + status = s; + } + } + float getValue() const { + + float adjusted_value = value; + if (late_days_used > 0) { + //std::cout << "LATE DAYS! " << late_days_used << std::endl; + // FIXME: Currently a flat penalty no matter how many days used + adjusted_value = (1-LATE_DAY_PERCENTAGE_PENALTY)*value; + //std::cout << "value " << value << "-> " << adjusted_value << std::endl; + } + + /* + // grab the maximum score for this homework + assert (PERFECT_STUDENT_POINTER != NULL); + std::map >::const_iterator ps_itr = PERFECT_STUDENT_POINTER->all_item_grades.find(g); + assert (ps_itr != all_item_grades.end()); + float ps_value = ps_itr->second[i].getValue(); + */ + // adjust the homework score + //value = std::max(0.0f, value - d*LATE_DAY_PERCENTAGE_PENALTY*ps_value); + + return adjusted_value; + } + int getLateDaysUsed() const { return late_days_used; } + const std::string& getNote() const { return note; } + const std::string& getStatus() const { return status; } +private: + float value; + int late_days_used; + std::string note; + std::string status; +}; + +//==================================================================== +//==================================================================== + +class Student { + +public: + + // --------------- + // CONSTRUCTOR + Student(); + + // --------------- + // ACCESSORS + + // personal data + const std::string& getUserName() const { return username; } + const std::string& getFirstName() const { return legal_first; } + const std::string& getPreferredName() const { if (preferred_first != "") return preferred_first; return legal_first; } + const std::string& getLastName() const { return last; } + const std::string& getLastUpdate() const { return lastUpdate; } + bool getLefty() const { return lefty; } + + // registration status + int getSection() const { return section; } + bool getAudit() const { return audit; } + bool getWithdraw() const { return withdraw; } + bool getIndependentStudy() const { return independentstudy; } + + // grade data + const ItemGrade& getGradeableItemGrade(GRADEABLE_ENUM g, int i) const; + std::string getZone(int i) const; + int getAllowedLateDays(int which_lecture) const; + int getUsedLateDays() const; + float getMossPenalty() const { return moss_penalty; } + + void setCurrentAllowedLateDays(int d) { current_allowed_late_days = d; } + void setDefaultAllowedLateDays(int d) { default_allowed_late_days = d; } + + int getDefaultAllowedLateDays() const { return default_allowed_late_days; } + + void add_bonus_late_day(int which_lecture) { bonus_late_days_which_lecture.push_back(which_lecture); } + + // other grade-like data + const std::vector& getRemoteID() const { return remote_id; } + bool getAcademicIntegrityForm() const { return academic_integrity_form; } + int getParticipation() const { return participation; } + int getUnderstanding() const { return understanding; } + + // info about exam assignments + const std::string& getExamRoom() const { return exam_room; } + const std::string& getExamZone() const { return exam_zone; } + std::string getExamRow() const { return exam_row;} + std::string getExamSeat() const { return exam_seat;} + const std::string& getExamTime() const { return exam_time; } + const std::string& getExamZoneImage() const { return exam_zone_image; } + + // per student notes + const std::string& getRecommendation() const { return ta_recommendation; } + const std::string& getOtherNote() const { return other_note; } + const std::vector& getEarlyWarnings() const { return early_warnings; } + + // --------------- + // MODIFIERS + + // personal data + void setUserName(const std::string &s) { username=s; } + void setLegalFirstName(const std::string &s) { legal_first=s; } + void setPreferredFirstName(const std::string &s) { preferred_first=s.substr(0,10); } + void setLastName(const std::string &s) { last=s; } + void setLefty() { lefty = true; } + void setLastUpdate(const std::string &s) { lastUpdate = s; } + + // registration status + void setSection(int x) { section = x; } + void setAudit() { audit = true; } + void setWithdraw() { withdraw = true; } + void setIndependentStudy() { independentstudy = true; } + + // grade data + void setTestZone(int which_test, const std::string &zone) { zones[which_test] = zone; } + void setGradeableItemGrade(GRADEABLE_ENUM g, int i, float value, int late_days_used=0, const std::string ¬e="",const std::string &status=""); + + void mossify(const std::string &gradeable, float penalty); + + // other grade-like data + void setRemoteID(const std::string& r_id) { remote_id.push_back(r_id); } + void setAcademicIntegrityForm() { academic_integrity_form = true; } + void setParticipation(int x) { participation = x; } + void setUnderstanding(int x) { understanding = x; } + + // info about exam assignments + void setExamRoom(const std::string &s) { exam_room = s; } + void setExamZone(const std::string &z, const std::string &r, const std::string &s) { exam_zone=z; exam_row=r; exam_seat=s; } + void setExamTime(const std::string &s) { exam_time = s; } + void setExamZoneImage(const std::string &s) { exam_zone_image = s; } + + // per student notes + void addWarning(const std::string &message) { early_warnings.push_back(message); } + void addRecommendation(const std::string &message) { ta_recommendation += message; } + void addNote(const std::string &message) { other_note += message; } + void ManualGrade(const std::string &grade, const std::string &message); + + + // --------------- + // I-CLICKER + + void addIClickerAnswer(const std::string& which_question, char which_answer, iclicker_answer_enum grade); + float getIClickerRecent() const; + float getIClickerTotalFromStart() const { return getIClickerTotal(100,0); } + float getIClickerTotal(int which_lecture, int start) const; + bool hasPriorityHelpStatus() const { + return (getIClickerRecent() >= ICLICKER_PRIORITY * float (ICLICKER_RECENT)); + } + std::pair getIClickerAnswer(const std::string& which_question) const; + + + // HELPER FUNCTIONS + float GradeablePercent(GRADEABLE_ENUM g) const; + float overall() const { return overall_b4_moss() + moss_penalty; } + float adjusted_test(int i) const; + float adjusted_test_pct() const; + float lowest_test_counts_half_pct() const; + float quiz_normalize_and_drop(int num) const; + float overall_b4_moss() const; + std::string grade(bool flag_b4_moss, Student *lowest_d) const; + void outputgrade(std::ostream &ostr,bool flag_b4_moss,Student *lowest_d) const; + +private: + + // --------------- + // REPRESENTATION + + // personal data + std::string username; + std::string legal_first; + std::string preferred_first; + std::string last; + bool lefty; + + std::string lastUpdate; + + int current_allowed_late_days; + int default_allowed_late_days; + + // registration status + int section; + bool audit; + bool withdraw; + bool independentstudy; + + // grade data + std::map > all_item_grades; + std::map > iclickeranswers; + + std::vector zones; + float moss_penalty; + float cached_hw; + + // other grade-like data + std::vector remote_id; + bool academic_integrity_form; + int participation; + int understanding; + + std::vector bonus_late_days_which_lecture; + + // info about exam assignments + std::string exam_zone; + std::string exam_row; + std::string exam_seat; + std::string exam_room; + std::string exam_time; + std::string exam_zone_image; + + // per student notes + std::string ta_recommendation; + std::string other_note; + std::string manual_grade; + std::vector early_warnings; +}; + +//==================================================================== +//==================================================================== + +Student* GetStudent(const std::vector &students, const std::string& username); + +#endif diff --git a/table.cpp b/table.cpp new file mode 100644 index 0000000..acb15d6 --- /dev/null +++ b/table.cpp @@ -0,0 +1,158 @@ +#include +#include + +#include "table.h" +#include "constants_and_globals.h" + +bool GLOBAL_instructor_output = false; + +bool global_details = false; + +TableCell::TableCell(const std::string& c, const std::string& d, const std::string& n, int ldu, + CELL_CONTENTS_STATUS v, const std::string& a, int s, int r) { + assert (c.size() == 6); + color=c; + data=d; + note=n; + late_days_used=ldu, + visible=v; + align=a; + span=s; + rotate=r; +} + +TableCell::TableCell(const std::string& c, int d, const std::string& n, int ldu, + CELL_CONTENTS_STATUS v, const std::string& a, int s, int r) { + assert (c.size() == 6); + color=c; + data=std::to_string(d); + note=n; + late_days_used=ldu, + visible=v; + align=a; + span=s; + rotate=r; +} + +TableCell::TableCell(const std::string& c, float d, int precision, const std::string& n, int ldu, + CELL_CONTENTS_STATUS v, const std::string& a, int s, int r) { + assert (c.size() == 6); + assert (precision >= 0); + color=c; + if (fabs(d) > 0.0001) { + std::stringstream ss; + ss << std::setprecision(precision) << std::fixed << d; + data=ss.str(); span=s; + } else { + data = ""; + } + note=n; + late_days_used=ldu, + visible=v; + align=a; + span=s; + rotate = 0; +} + +std::ostream& operator<<(std::ostream &ostr, const TableCell &c) { + assert (c.color.size() == 6); + // ostr << ""; + ostr << ""; + if (0) { //rotate == 90) { + ostr << "

"; + } + ostr << ""; + std::string mynote = c.getNote(); + if ((c.data == "" && mynote=="") + || c.visible==CELL_CONTENTS_HIDDEN + || (c.visible==CELL_CONTENTS_VISIBLE_INSTRUCTOR && GLOBAL_instructor_output == false) + || (c.visible==CELL_CONTENTS_VISIBLE_STUDENT && GLOBAL_instructor_output == true)) { + ostr << "

"; + } else { + ostr << c.data; + if (c.late_days_used > 0) { + if (c.late_days_used > 3) { ostr << " (" << std::to_string(c.late_days_used) << "*)"; } + else { ostr << " " << std::string(c.late_days_used,'*'); } + } + if (mynote.length() > 0 && + mynote != " " && + (global_details + /* + || + c.visible==CELL_CONTENTS_HIDDEN + */ + ) + ) { + ostr << "
" << mynote << ""; + } + } + ostr << ""; + if (0) { //rotate == 90) { + ostr << "

"; + } + ostr << ""; + return ostr; +} + + + +void Table::output(std::ostream& ostr, + std::vector which_students, + std::vector which_data, + bool transpose, + bool show_details, + std::string last_update) const { + + global_details = show_details; + //global_details = true; + + ostr << "\n"; + + + // ------------------------------------------------------------------------------- + // PRINT INSTRUCTOR SUPPLIED MESSAGES + for (unsigned int i = 0; i < MESSAGES.size(); i++) { + ostr << "" << MESSAGES[i] << "
\n"; + } + if (last_update != "") { + ostr << "Information last updated: " << last_update << "
\n"; + } + ostr << " 
\n"; + + + ostr << "\n"; + // ostr << "
\n"; + + if (transpose) { + for (std::vector::iterator c = which_data.begin(); c != which_data.end(); c++) { + ostr << "\n"; + for (std::vector::iterator r = which_students.begin(); r != which_students.end(); r++) { + ostr << cells[*r][*c] << "\n"; + } + ostr << "\n"; + } + } else { + for (std::vector::iterator r = which_students.begin(); r != which_students.end(); r++) { + ostr << "\n"; + for (std::vector::iterator c = which_data.begin(); c != which_data.end(); c++) { + ostr << cells[*r][*c] << "\n"; + } + ostr << "\n"; + } + } + + ostr << "
" << std::endl; +} diff --git a/table.h b/table.h new file mode 100644 index 0000000..3677bfa --- /dev/null +++ b/table.h @@ -0,0 +1,70 @@ +#include +#include +#include +#include +#include + +extern bool GLOBAL_instructor_output; + +enum CELL_CONTENTS_STATUS { CELL_CONTENTS_VISIBLE, CELL_CONTENTS_HIDDEN, CELL_CONTENTS_VISIBLE_STUDENT, CELL_CONTENTS_VISIBLE_INSTRUCTOR, CELL_CONTENTS_NO_DETAILS }; + +class TableCell { +public: + + // CONSTRUCTORS + TableCell(const std::string& c="ffcccc", const std::string& d="", const std::string& n="", int ldu=0, + CELL_CONTENTS_STATUS v=CELL_CONTENTS_VISIBLE, const std::string& a="left" , int s=1, int r=0); + TableCell(const std::string& c , int d , const std::string& n="", int ldu=0, + CELL_CONTENTS_STATUS v=CELL_CONTENTS_VISIBLE, const std::string& a="left" , int s=1, int r=0); + TableCell(const std::string& c , float d , int precision, const std::string& n="", int ldu=0, + CELL_CONTENTS_STATUS v=CELL_CONTENTS_VISIBLE, const std::string& a="right", int s=1, int r=0); + + std::string color; + std::string data; + int late_days_used; + std::string align; + enum CELL_CONTENTS_STATUS visible; + int span; + int rotate; + friend std::ostream& operator<<(std::ostream &ostr, const TableCell &c); + const std::string& getNote() const { return note; } +private: + std::string note; +}; + + + +class Table { + +public: + + Table() { + cells = std::vector>(1,std::vector(1)); + } + + void set(int r, int c, TableCell cell) { + while(r >= numRows()) { + cells.push_back(std::vector(numCols())); + } + while (c >= numCols()) { + for (int x = 0; x < numRows(); x++) { + cells[x].push_back(TableCell()); + } + } + cells[r][c] = cell; + } + + void output(std::ostream& ostr, + std::vector which_students, + std::vector which_data, + bool transpose=false, + bool show_details=false, + std::string last_update="") const; + + + int numRows() const { return cells.size(); } + int numCols() const { return cells[0].size(); } + +private: + std::vector> cells; +}; diff --git a/zone.cpp b/zone.cpp new file mode 100644 index 0000000..5c19a63 --- /dev/null +++ b/zone.cpp @@ -0,0 +1,468 @@ +#include +#include +#include + + +#include "student.h" +#include "constants_and_globals.h" + +//========================================================================== + +bool is_lefty_seat(const std::string& s) { + return s.back() == 'L'; +} + +class ZoneInfo { +public: + ZoneInfo() { max = 0; count = 0; } + std::string building; + std::string room; + std::string zone; + std::string image_url; + int max; + int count; + bool take_seat(std::string r, std::string s) { + assert (count < max); + std::vector >* available_seats; + if (is_lefty_seat(s)) { + available_seats = &available_lefty_seats; + } else { + available_seats = &available_nonlefty_seats; + } + for (std::vector >::iterator itr = available_seats->begin(); + itr != available_seats->end(); itr++) { + if (itr->first == r && itr->second == s) { + available_seats->erase(itr); + count++; + return true; + } + } + return false; + } + void assign_seat(std::string &r, std::string &s, bool is_lefty) { + if (num_available_seats() == 0) { + r = "N/A"; + s = "N/A"; + count++; + return; + } + + std::vector >* available_seats; + if (is_lefty) { + available_seats = &available_lefty_seats; + } else { + available_seats = &available_nonlefty_seats; + } + assert (available_seats->size() > 0); + assert (count < max); + + int random_seat = std::rand()%available_seats->size(); + std::vector >::iterator itr = available_seats->begin() + random_seat; + assert (itr != available_seats->end()); + r = itr->first; + s = itr->second; + available_seats->erase(itr); + count++; + } + void clear_seats() { + available_lefty_seats.clear(); + available_nonlefty_seats.clear(); + } + int num_available_seats() { + return available_lefty_seats.size() + available_nonlefty_seats.size(); + } + int num_lefty_seats() { + return available_lefty_seats.size(); + } + void add_seat(const std::string &r, const std::string &s) { + if (is_lefty_seat(s)) { + available_lefty_seats.push_back(std::make_pair(r,s)); + } else { + available_nonlefty_seats.push_back(std::make_pair(r,s)); + } + } +private: + std::vector > available_lefty_seats; + std::vector > available_nonlefty_seats; +}; + + +// random generator function: +int myrandomzone (int i) { return std::rand()%i;} + +//========================================================================== + +// More intuitive sort function to organize zones first by length (# +// of characters), then alphabetical. +class ZoneSorter { +public: + bool operator()(const std::string& a, const std::string& b) const { + return (a.size() < b.size() || + (a.size() == b.size() && a < b)); + } +}; + + +int CountLefties(std::vector &students,const std::string& lefty_file, float min_for_assignment) { + if (lefty_file == "") return 0; + std::ifstream istr(lefty_file.c_str()); + assert (istr.good()); + + int count = 0; + std::string user,handedness; + while (istr >> user >> handedness) { + Student *s = GetStudent(students,user); + assert (s != NULL); + if (handedness == "left") { + //std::cout << "LEFTY " << user << std::endl; + s->setLefty(); + if (s->getExamRoom() != "") { + std::cout << "ALREADY ASSIGNED ROOM " << user << std::endl; + } else if (s->overall() < GLOBAL_MIN_OVERALL_FOR_ZONE_ASSIGNMENT) { + std::cout << "NOT ASSIGNING LEFTY " << user << std::endl; + } else { + std::cout << "NEED SEAT FOR LEFTY " << user << std::endl; + count++; + } + } + } + return count; +} + +void LoadExamSeatingFile(const std::string &zone_counts_filename, + const std::string &zone_assignments_filename, + const std::string &seating_spacing, + const std::string &left_right_handedness, + std::vector &students) { + + + std::cout << "zone counts filename '" << zone_counts_filename << "'" << std::endl; + std::cout << "zone assignments filename '" << zone_assignments_filename << "'" << std::endl; + std::cout << "left_right_handedness '" << left_right_handedness << "'" << std::endl; + std::cout << "min overall " << GLOBAL_MIN_OVERALL_FOR_ZONE_ASSIGNMENT << std::endl; + + assert (zone_counts_filename != ""); + assert (zone_assignments_filename != ""); + + int num_lefties = CountLefties(students,left_right_handedness, GLOBAL_MIN_OVERALL_FOR_ZONE_ASSIGNMENT); + + std::cout << "NUM LEFTIES " << num_lefties << std::endl; + + // ============================================================ + // read in the desired zone counts + + std::map zones; + std::ifstream istr_zone_counts(zone_counts_filename.c_str()); + assert (istr_zone_counts.good()); + + int total_seats = 0; + ZoneInfo zi; + + std::string line; + + int lefty_desk_count = 0; + + std::string token; + istr_zone_counts >> token; + assert (token == "zone"); + while (1) { + + std::getline(istr_zone_counts,line); + std::stringstream ss(line); + + if (!(ss >> zi.zone >> zi.building >> zi.room >> zi.max)) { + std::cout << "MISFORMATTED ZONE COUNTS" << std::endl; exit(1); } + ss >> zi.image_url; + + zi.count=0; + zi.clear_seats(); + if (zones.find(zi.zone) != zones.end()) { + std::cerr << "\nERROR: duplicate zone " << zi.zone << " in " << zone_counts_filename << std::endl; + exit(0); + } + if (zi.max != -1) { + assert (zi.max >= 0); + total_seats += zi.max; + } + + bool read_another_zone = false; + while (istr_zone_counts >> token) { + //std::cout << "======================================\nTOKEN " << token << std::endl; + if (token[0] == '#') { + std::getline(istr_zone_counts,line); + //std::cout << "COMMENTED LINE " << line << std::endl; + continue; + } else if (token == "row") { + std::getline(istr_zone_counts,line); + std::stringstream ss(line); + std::string row,seat; + ss >> row >> token; + assert (token == ":"); + std::vector all_seats; + while (ss >> seat) { + all_seats.push_back(seat); + } + bool skip = false; + for (int i = 0; i < all_seats.size(); i++) { + seat = all_seats[i]; + //std::cout << "SEAT " << seat << std::endl; + if (seat.back() == 'X') { + //std::cout << "BROKEN DESK " << zi.zone << " "<< row << " " << seat << std::endl; + continue; + } + if (skip) { + skip = false; + //std::cout << "SKIPPING " << zi.zone << " "<< row << " " << seat << std::endl; + continue; + } + if (seat.back() == 'L') { + //std::cout << "LEFTY DESK " << zi.zone << " " << row << " " << seat << std::endl; + lefty_desk_count++; + } + skip = true; + //std::cout << "SEAT " << seat << std::endl; + zi.add_seat(row,all_seats[i]); + } + } else if (token == "zone") { + read_another_zone = true; + break; + } else { + assert (0); + } + if (token == "zone") { + read_another_zone = true; + break; + } + } + if (zi.max == -1) { + zi.max = zi.num_available_seats(); + total_seats += zi.max; + } + if (zi.num_available_seats() != 0 && + zi.max != zi.num_available_seats()) { + std::cout << "AVAILABLE SEATS FOR ZONE " << zi.zone << " are incorrect " << + zi.max << " max vs " << zi.num_available_seats() << " available" << std::endl; + exit(1); + } + zones.insert(std::make_pair(zi.zone,zi)); + if (!read_another_zone) break; + + } + std::cout << "TOTAL SEATS FOR EXAM " << total_seats << std::endl; + std::cout << "LEFTY DESK COUNT " << lefty_desk_count << std::endl; + + // if we don't have specific seating assignments in this zone, + // fill in with generic seats + for (std::map::iterator itr = zones.begin(); itr != zones.end(); itr++) { + int max = itr->second.max; + int na = itr->second.num_available_seats(); + assert (max >= na); + for (int i = 0; i < max-na; i++) { + itr->second.add_seat("N/A","N/A"); + } + } + + // ============================================================ + // read in any existing assignments... + + std::cout << "READING " << zone_assignments_filename << std::endl; + + int existing_assignments = 0; + { + std::ifstream istr_zone_assignments(zone_assignments_filename.c_str()); + if (istr_zone_assignments.good()) { + std::string line; + while (getline(istr_zone_assignments,line)) { + std::stringstream ss(line.c_str()); + std::string token,last,first,rcs,section,building,room,zone,row,seat,time; + ss >> last >> first >> rcs >> section >> building >> room >> zone >> row >> seat >> time; + + while (ss >> token) { time += " " + token; } + + //std::cout << "FOUND " << rcs << std::endl; + + if (last == "") break; + Student *s = GetStudent(students,rcs); + if (s == NULL) { + std::cout << "seating assignment... couldn't find this userid " << rcs << std::endl; + } + assert (s != NULL); + if (zone != "") { + std::map::iterator itr = zones.find(zone); + if (itr == zones.end()) { + std::cerr << "ERROR! this zone '" << zone << "' assigned to '" << s->getUserName() << "'does not exist!" << std::endl; + exit(1); + } + if (itr->second.max <= itr->second.count) { + std::cerr << "ERROR! this zone '" << zone << "' is full (max:" << itr->second.max << ")" << std::endl; + exit(1); + } + assert (itr->second.building == building); + assert (itr->second.room == room); + bool success = itr->second.take_seat(row,seat); + if (!success) { + std::cout << "ERROR COULD NOT TAKE SEAT " << zone << " row:" << row + << " seat:" << seat << std::endl; + exit(1); + } + + existing_assignments++; + s->setExamRoom(building+std::string(" ")+room); + s->setExamZone(zone,row,seat); + s->setExamZoneImage(itr->second.image_url); + if (time != "") { + s->setExamTime(time); + } else { + s->setExamTime(GLOBAL_EXAM_TIME); + } + } + } + } + } + std::cout << "EXISTING ASSIGNMENTS " << existing_assignments << std::endl; + + // ============================================================ + // make a vector of available seats + + // FIXME: this belongs once, at start of program + std::srand ( unsigned ( std::time(0) ) ); + + std::vector randomized_lefty_available; + std::vector randomized_nonlefty_available; + for (std::map::iterator itr = zones.begin(); itr != zones.end(); itr++) { + assert (itr->second.count <= itr->second.max); + int num_l = itr->second.num_lefty_seats(); + int num_nl = itr->second.num_available_seats() - num_l; + for (int i = 0; i < num_l; i++) { + randomized_lefty_available.push_back(itr->first); + } + for (int i = 0; i < num_nl; i++) { + randomized_nonlefty_available.push_back(itr->first); + } + } + std::cout << "AVAILABLE LEFTY SEATS " << randomized_lefty_available.size() << std::endl; + std::cout << "AVAILABLE NONLEFTY SEATS " << randomized_nonlefty_available.size() << std::endl; + std::random_shuffle ( randomized_lefty_available.begin(), randomized_lefty_available.end(), myrandomzone ); + std::random_shuffle ( randomized_nonlefty_available.begin(), randomized_nonlefty_available.end(), myrandomzone ); + + // ============================================================ + // do the assignments! + + int not_reg = 0; + int low_overall_grade = 0; + int new_zone_assign = 0; + int already_zoned = 0; + int next_lefty_za = 0; + int next_nonlefty_za = 0; + + for (unsigned int i = 0; i < students.size(); i++) { + + Student* &s = students[i]; + + if (s->getExamRoom() != "") { + already_zoned++; + } else if (!validSection(s->getSection())) { + not_reg++; + } else if (s->overall() < GLOBAL_MIN_OVERALL_FOR_ZONE_ASSIGNMENT) { + low_overall_grade++; + } else { + + if (s->getLefty()) { + if (next_lefty_za >= (int)randomized_lefty_available.size()) { + std::cout << "OOPS! we ran out of lefty exam seating" << std::endl; + } + assert (next_lefty_za < (int)randomized_lefty_available.size()); + ZoneInfo &next_zi = zones.find(randomized_lefty_available[next_lefty_za])->second; + s->setExamRoom(next_zi.building+std::string(" ")+next_zi.room); + std::string row,seat; + //std::cout << "ASSIGN student " << s->getUserName() << std::endl; + next_zi.assign_seat(row,seat,s->getLefty()); + s->setExamZone(next_zi.zone,row,seat); + s->setExamZoneImage(next_zi.image_url); + next_lefty_za++; + new_zone_assign++; + } else { + if (next_nonlefty_za >= (int)randomized_nonlefty_available.size()) { + std::cout << "OOPS! we ran out of nonlefty exam seating" << std::endl; + } + assert (next_nonlefty_za < (int)randomized_nonlefty_available.size()); + ZoneInfo &next_zi = zones.find(randomized_nonlefty_available[next_nonlefty_za])->second; + s->setExamRoom(next_zi.building+std::string(" ")+next_zi.room); + std::string row,seat; + //std::cout << "ASSIGN student " << s->getUserName() << std::endl; + next_zi.assign_seat(row,seat,s->getLefty()); + s->setExamZone(next_zi.zone,row,seat); + s->setExamZoneImage(next_zi.image_url); + next_nonlefty_za++; + new_zone_assign++; + } + } + } + + std::cout << "new zone assignments " << new_zone_assign << std::endl; + std::cout << "low overall grade (not assigning a zone) " << low_overall_grade << std::endl; + std::cout << "not registered in valid section " << not_reg << std::endl; + + assert (new_zone_assign <= + int(randomized_lefty_available.size()) + + int(randomized_nonlefty_available.size())); + + + // ============================================================ + // write out the assignments! + + if (1) { //new_zone_assign > 0) { + + std::ofstream ostr_zone_assignments(zone_assignments_filename.c_str()); + assert (ostr_zone_assignments.good()); + + for (unsigned int i = 0; i < students.size(); i++) { + + Student* &s = students[i]; + + if (s->getLastName() == "") continue; + + std::string f = s->getPreferredName(); + std::string l = s->getLastName(); + std::replace( f.begin(), f.end(), ' ', '_'); + std::replace( l.begin(), l.end(), ' ', '_'); + + ostr_zone_assignments << std::setw(20) << std::left << l << " "; + ostr_zone_assignments << std::setw(15) << std::left << f << " "; + ostr_zone_assignments << std::setw(12) << std::left << s->getUserName() << " "; + if (s->getSection()) + ostr_zone_assignments << std::setw(12) << std::left << s->getSection() << " "; + else + ostr_zone_assignments << std::setw(12) << std::left << "" << " "; + + ostr_zone_assignments << std::setw(10) << std::left << s->getExamRoom() << " "; + ostr_zone_assignments << std::setw(10) << std::left << s->getExamZone() << " "; + ostr_zone_assignments << std::setw(10) << std::left << s->getExamRow() << " "; + ostr_zone_assignments << std::setw(10) << std::left << s->getExamSeat() << " "; + ostr_zone_assignments << std::setw(10) << std::left << s->getExamTime(); + + ostr_zone_assignments << std::endl; + + } + + } + + // ============================================================ + // data for preparing exams + + + int total_assignments = 0; + for (std::map::iterator itr = zones.begin(); + itr != zones.end(); itr++) { + + std::cout << "ZONE " << std::left << std::setw(6) << itr->first + << " " << std::left << std::setw(10) << itr->second.building << " " + << " " << std::left << std::setw(4) << itr->second.room << " " + << " " << std::right << std::setw(4) << itr->second.count << " (" << itr->second.max-itr->second.count << " seats remain)" << std::endl; + + total_assignments += itr->second.count; + } + std::cout << "TOTAL " << total_assignments << std::endl; + + +}